Saravanan666/pypi-org huggingface dataset:
Package: obscure-password
obscure-passwordOverviewobscure-password is a self contained obfuscation library for hardcoded passwords (or other text) in Python scripts. Obfuscation is a technique to prevent the unskilled or casual observer access to sensitive data and provide an impediment to the skilled i.e. requiring explicit effort to circumvent.
Typical use cases are in casual software development or  debugging where a developer may be sharing scripts with field technicians to perform one-off tasks.Usage>>>fromobscure_passwordimportobscure,unobscure>>>obscured=obscure('my sensitive information')>>>print(obscured)fxFpdVRHWRJjTkFnN0lmMTQ7NSslBB4jby8kMgofJFU5Lz0A>>>unobscure(obscured)'my sensitive information'obscure_password laces the obscured text with a marker which enables it to avoid unobscuring text that has not been obscured.>>>fromobscure_passwordimportobscure,unobscure>>>unobscure('my sensitive information')'my sensitive information'This is helpful when developing a script and wanting to regularly change the password.LimitationsOfuscation is NOT secure!obscure-password was designed for password obfuscation and not to obscure large texts. The base64 encoding increases the obscured text length by x1.25 plus 16 characters, for the marker, over the original text length.The text size obscured / unobscured is unrestricted (limited by RAM & patience). As a first approximation for large texts memory required is +1.25x the original text size.Sunburst Code Coverage ChartThe inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.
Package: obscure_stats
obscure_statsCI/CDSecurityPackageMetaHighlights:obscure_statsis a small Python package that includes a lot of useful but lesser-known statistical functions and builds on top ofnumpyandscipy.Current API listCollection of measures of central tendency -obscure_stats/central_tendency:Contraharmonic Mean;Half-Sample Mode;Hodges-Lehmann-Sen Location;Midhinge;Midmean;Midrange;Standard Trimmed Harrell-Davis Quantile;Trimean.Collection of measures of dispersion -obscure_stats/dispersion:Coefficient of Range;Coefficient of Variation;Cole's Index of Dispersion;Dispersion Ratio;Fisher's Index of Dispersion;Gini Mean Difference;Linear Coefficient of Variation;Morisita Index of Dispersion;Quartile Coefficient of Dispersion;Robust Coefficient of Variation;Shamos Estimator;Standard Quantile Absolute Deviation;Studentized Range.Collection of measures of skewness -obscure_stats/skewness:Area Under the Skewness Curve (weighted and unweighted);Bickel Mode Skewness Coefficient;Bowley Skewness Coefficient;Cumulative Skewness Coefficient;Forhad-Shorna Rank Skewness Coefficient;Groeneveld Skewness Coefficient;Hossain-Adnan Skewness Coefficient;Kelly Skewness Coefficient;L-Skewness Coefficient;Medeen Skewness Coefficient;Pearson Median Skewness Coefficient;Pearson Mode Skewness Coefficient.Collection of measures of kurtosis -obscure_stats/kurtosis:Crow-Siddiqui Kurtosis;L-Kurtosis;Hogg Kurtosis;Moors Kurtosis;Moors Octile Kurtosis;Reza-Ma Kurtosis.Collection of measures of association -obscure_stats/association:Blomqvist's Beta;Chatterjee Xi Correlation Coefficient (original and symmetric versions);Concordance Correlation Coefficient;Concordance Rate;Rank Minrelation Coefficient;Tanimoto Similarity;Tukey's Correlation Coefficient;Winsorized Correlation Coefficient;Zhang I Correlation Coefficient.Collection of measures of qualitative variation -obscure_stats/variation:AVDev;B Index;Gibbs M1;Gibbs M2;McIntosh's D;ModVR;Negative Extropy;RanVR;Rényi entropy.Installation>>>pipinstallobscure_statsUsage Example>>>fromobscure_stats.central_tendencyimportstandard_trimmed_harrell_davis_quantile>>>fromobscure_stats.dispersionimportstandard_quantile_absolute_deviation>>>data=[1.83,1.01,100.12,1.20,0.99,0.87,1.13,100.01,0.75,1.03]>>>central_tendency=standard_trimmed_harrell_davis_quantile(data)>>>dispersion=standard_quantile_absolute_deviation(data)>>>print(f"Robust measure of central tendency ={central_tendency:.2f}±{dispersion:.2f}")Out[1]:
Robust measure of central tendency = 1.09±0.42Code of ConductCode of Conduct for this project can be foundhere.ContributingContribution guidelines for this project can be foundhere.Security PolicySecurity Policy for this project can be foundhere.LicenseThe content of this repository is licensed under aMIT license.This repository bundles several libraries that are compatibly licensed. A full list can be foundhere.
Package: obsd-crypt
OpenBSD cryptPython 3 wrapper for OpenBSDscrypt_checkpass(3)andcrypt_newhash(3)Usage$ python3
Python 3.8.12 (default, Sep 26 2021, 13:12:50)
[Clang 11.1.0 ] on openbsd7
Type "help", "copyright", "credits" or "license" for more information.
>>> from obsd_crypt import crypt_checkpass, crypt_newhash
>>> pass_hash = crypt_newhash("password")
>>> print(pass_hash)
$2b$10$RoAK6.GPdcXZId.cmFhmG.5YbXmANB/FyvzIbxj8uCKQWqRubiwee
>>> crypt_checkpass("password", pass_hash)
TrueFunctionscrypt_checkpass(password: str, hash: str) -> boolCheck a password against a given hash.If both the hash and the password are the empty string, authentication is a success. Otherwise, the password is hashed and compared to the provided hash. If the hash is empty, authentication will always fail, but a default amount of work is performed to simulate the hashing operation. A successful match returns True and a failure returns False.crypt_newhash(password: str, rounds: int = -1) -> strReturn a new hash for a password.The provided password is randomly salted and hashed and returned as a string using the bcrypt algorith. The number of rounds  can be any integer between 4 and 31, inclusive. If the number of rounds is not given or is negative, an appropriate number of rounds is automatically selected based on system performance.
Package: obse
obseOntology Based System EngineeringInstallationpipinstallobseInstallation for development purposespip install -e .Usagecreate Graphfrom rdflib import Graph, URIRef
from obse.graphwrapper import GraphWrapper


graph = Graph()

graph_wrapper = GraphWrapper(graph)
instance_type = URIRef("https://www.frittenburger.de/test#TestClass")
graph_wrapper.add_named_instance(instance_type, "test-instance")

graph.serialize(destination="model.ttl, format='turtle')read Graphfrom rdflib import Graph, URIRef
from obse.sparql_queries import SparQLWrapper


graph = Graph()
graph.parse("model.ttl")
graph_wrapper = SparQLWrapper(graph)
instances = graph_wrapper.get_instances()ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.Authors and acknowledgmentFor readme file I used format fromhttps://www.makeareadme.com/LicenseGNU GPLv3
Package: obsea
Obsea metamorphoses Ocean-Bottom Seismometers (OBS) into watchful observers of the Oceans. Sensing infrasound, OBSs can record marine mammal vocalizes, ship traffic noise, iceberg activity and more at very long rages (~100 km). This package aims at automatically recognizing and localizing acoustical sources that can be recorded by OBSs transforming this latter into an efficient acoustic passive sonar.Documentation can be found at:https://obsea.readthedocs.io/en/latest/Related publications:Trabattoni, A., Barruol, G., Dreo, R., Boudraa, A. O., & Fontaine, F. R. (2019). Orienting and locating ocean-bottom seismometers from ship noise analysis. Geophysical Journal International, ggz519.https://doi.org/10.1093/gji/ggz519Trabattoni, A., Barruol, G., Dréo, R., & Boudraa, A. (2023). Ship detection and tracking from single ocean-bottom seismic and hydroacoustic stations. The Journal of the Acoustical Society of America, 153(1), 260–273.https://doi.org/10.1121/10.0016810
Package: observ
Observ 👁Observ is a Python port ofVue.js'computed properties and watchers. It is event loop/framework agnostic and has only one pure-python dependency (patchdiff) so it can be used in any project targeting Python >= 3.9.Observ provides the following two benefits for stateful applications:You no longer need to manually invalidate and recompute state (e.g. by dirty flags):computed state is invalidated automaticallycomputed state is lazily re-evaluatedYou can react to changes in state (computed or not), enabling unidirectional flow:state changeslead toview changes(e.g. a state change callback updates a UI widget)theviewtriggersinput events(e.g. a mouse event is triggered in the UI)input eventslead tostate changes(e.g. a mouse event updates the state)APIfrom observ import reactive, computed, watchstate = reactive(state)Observe nested structures of dicts, lists, tuples and sets. Returns an observable proxy that wraps the state input object.watcher = watch(func, callback, deep=False, immediate=False)React to changes in the state accessed infuncwithcallback(old_value, new_value). Returns a watcher object.delelete it to disable the callback.wrapped_func = computed(func)Define computed state based on observable state withfuncand recompute lazily. Returns a wrapped copy of the function which only recomputes the output if any of the state it depends on becomes dirty. Can be used as a function decorator.Note:The API has evolved and become more powerful since the original creation of this README. Track issue #10 to follow updates to observ's documentation.Quick start and examplesInstall observ with pip/pipenv/poetry:pip install observCheck outexamples/observe_qt.pyfor a simple example using observ.Check outexamples/store_with_undo_redo.pyfor a simple example using the included undo/redo-capable Store abstraction.CaveatObserv keeps references to the object passed to thereactivein order to keep track of dependencies and proxies for that object. When the object that is passed intoreactiveis not managed by other code, then observ should cleanup its references automatically when the proxy is destroyed. However, if there is another reference to the original object, then observ will only release its own reference when the garbage collector is run and all other references to the object are gone. For this reason, thebest practiseis to keepno referencesto the raw data, and instead work with the reactive proxiesonly.
Package: observable
# observable[![Build Status](https://travis-ci.com/timofurrer/observable.svg?branch=master)](https://travis-ci.com/timofurrer/observable)[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)**pyobservable** is a minimalist event system for python. It provides you an easy-to-use interface to trigger arbitrary functions when specific events occur.```pythonfrom observable import Observableobs = Observable()@obs.on("error")def error_handler(message):# do some fancy error handlinglogging.error(f"An error occured: {message}")...def do_time_travel():# do some time traveling...if year != 1291:obs.trigger("error", "Time travel to 1291 didn't work")```**Note:** We are Python 3 only! Only Python Versions >= 3.5 are supported. Use [v0.3.2](https://pypi.org/project/observable/0.3.2/) for older Python Versions.## How to useUse a `pip` to install it from PyPI:pip install observableAfter completion you can start using `observable`:```pythonfrom observable import Observableobs = Observable()```## Usage### `on`: Register event handler with `on`There are two ways to register a function to an event.<br />The first way is to register the event with a decorator like this:```python@obs.on("error")def error_func(message):print("Error: %s" % message)```The second way is to register it with a method call:```pythondef error_func(message):print("Error: %s" % message)obs.on("error", error_func)```### `once`: Register event handler with `once``once` works like `on`, but once the event handler is triggered it will be removed and cannot be triggered again.### `trigger`: trigger eventYou can trigger a registered event with the `trigger` method:```pythonobs.trigger("error", "This is my error message")```If no handler for the event `error` could be found an `Observable.NoHandlerFound`-Exception will be raised.### `off`: remove handler and eventsRemove a handler from a specified event:```pythonobs.off("error", error_func)``````pythonobs.off("error", [error_func, second_error_func])```Remove all handlers from a specified event:```pythonobs.off("error")```Clear all events:```pythonobs.off()```### `get_all_handlers`, `get_handlers` and `is_registered`: Check which handlers are registeredImagine you registered the following handlers:```python@obs.on("success")def success_func():print("Success!")@obs.on("error")def error_func(message):print("Error: %s" % message)```Then you can do the following to inspect the registered handlers:```python>>> obs.get_all_handlers(){'success': [<function success_func at 0x7f7f32d0a1e0>], 'error': [<function error_func at 0x7f7f32d0a268>]}>>> obs.get_handlers("success")[<function success_func at 0x7f7f32d0a1e0>]>>> obs.get_handlers("other_event")[]```****<p align="center">This project is published under [MIT](LICENSE).<br>A [Timo Furrer](https://tuxtimo.me) project.<br>- :tada: -</p>*
Package: observable-collections
Observable CollectionsA Rx based collections implementation in PythonIt contains following Observable collections and internally depends onRxPy* ObservableList
* ObservableDict
* ObservableSetThese collections exposewhen_collection_changes()method that creates an Observable which can be subscribed.Any changes to theObservableList / ObservableSet / ObservableDictthat modifies the collection, publishes the event either via on_next or error via on_errorInstallation#####Requires Python 3.5+pip install observable-collectionsExamplefromreactive.ObservableListimportObservableListol=ObservableList([1,2,3,4])ol.when_collection_changes()\.map(lambdax:x.Items)\.subscribe(print,print)ol.append(5)
Package: observable-jupyter
observable-jupyterEmbed cells fromObservablenotebooks into Jupyter notebooks.View demo notebook on ColabThis library provides a simple way to embed cells and pass custom inputs values to them from Python code. For more complicated data flow in Jupyter notebooks, see the related libraryobservable-jupyter-widgetwhich uses the Jupyter Widget system to pass data back and forth between Python and JavaScript.UsageTo install the library, import the embed function, and embed the "graphic" cell fromthis Observable notebook:!pipinstallobservable_jupyterfromobservable_jupyterimportembedembed('@mbostock/epicyclic-gearing',cells=['graphic'],inputs={'speed':0.2})The simplest way to useembed()is to render an entire Observable notebook:embed('@d3/gallery')You may want to swap in your own data into a D3 chart:importthistext=''.join(this.d.get(l,l)forlinthis.s)embed('@d3/word-cloud',cells=['chart'],inputs={'source':text})With multiple cells, you can embed interactive charts!embed('@observablehq/visualize-a-data-frame-with-observable-in-jupyter,cells=['vegaPetalsWidget','viewof sepalLengthLimits','viewof sepalWidthLimits'],)Embedding specific cells with the cell keyword parameter ofembed([])causes only these cells to be shown, but every cell still runs.This behavior is slightly different than the Observable embed default.About this libraryThis library uses the APIs provided byObservableto embed notebooks hosted on Observable in Jupyter.The library wasdeveloped at Observablebut is now maintained by Thomas Ballinger.
All code added before Sept 2021 is copyright Observable.DevelopmentSeeARCHITECTURE.mdfor an overview.Because Python library includes JavaScript, you'll need node as well as Python to contribute to it.The two JavaScript files included in an installed package iframe_bundle.js and wrapper_bundle.js are not saved in this repo.
They are generated by rollup, a JavaScript "bundler" that combines JavaScript source code
from files in the js folder and dependencies listed injs/package.json.Installing the Python package with orpip install -e .will automatically run the bundler and produce these files.
Package: observable-variable
observable_variableGitHub|PyPIDo you want to call a function every time a variable gets a new value?This package allows you to create an observable. This instance of theObservableVariableclass has an attributevalue. If you set a new value to this attribute, every callback will be called. You can add callbacks by calling the methodbindwith the function and arguments to be passed to the callback. Removing is as easy as to callunbindwith the same callback and arguments or by callingunbind_allto remove all bound callbacks for this observable. By default the new value will be the first argument to be passed to the callback. To disable this set the attributesend_valueto False.obs=ObservableVariable()defmy_callback(value,first_arg,second_arg):print("New value:",value)print("First argument:",first_arg)print("Second argument:",second_arg)# binding a callbackobs.bind(my_callback,"arg 1","arg 2")obs.value=1>>>Newvalue:1>>>Firstargument:arg1>>>Secondargument:arg2# unbinding a specific function-args-combinationobs.unbind(my_callback,"arg 1","arg 2")obs.value=2# callback not calledobs.bind(lambdavalue:print(value))# unbind all callbacksobs.unbind_all()obs.value=3# again callback not called# deactivating the sending of the new value as the first argumentobs.send_value=False
Package: observacode
observacodeA JupyterLab extension.This extension is composed of a Python package namedobservacodefor the server extension and a NPM package namedobservacodefor the frontend extension.RequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstallobservacodeUninstallTo remove the extension, execute:pipuninstallobservacodeTroubleshootIf you are seeing the frontend extension, but it is not working, check
that the server extension is enabled:jupyterserverextensionlistIf the server extension is installed and enabled, but you are not seeing
the frontend extension, check the frontend extension is installed:jupyterlabextensionlistContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the observacode directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Server extension must be manually installed in develop modejupyterserverextensionenableobservacode# Rebuild extension Typescript source after making changesjlpmbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstall# Server extension must be manually disabled in develop modejupyterserverextensiondisableobservacode
pipuninstallobservacodeIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink namedobservacodewithin that folder.Packaging the extensionSeeRELEASE
Package: observatory-platform
The Observatory Platform is an environment for fetching, processing and analysing data to understand how well
universities operate as Open Knowledge Institutions.The Observatory Platform is built with Apache Airflow. The workflows for the project can be seen in theAcademic Observatory WorkflowsandOAeBU Workflowsprojects.DocumentationFor more detailed documentation about the Observatory Platform see the Read the Docs websitehttps://observatory-platform.readthedocs.io
Package: observattr
ObservAttr: Observable AttributesPure Python implementation of observable class instance attributes (or a sort of reactive variables). It uses a descriptor that returns a proxy object which can be observed.The proxy object defines all public methods of the underlying object, and notifies subscribers after method calls. Callables can be subscribed to the proxy object and are notified with the underlying object as argument.The descriptor instantiates the proxy object after instantiating an instance of the parent class. So it is not an observable class attribute, but an observable instance attribute. For immutable types (e.g. Number), the__set__implementation copies the observers and returns a new proxy upon variable assignment. No change of type is allowed upon new descriptor variable assignment.Usagefrom observattr import ObservableAttributeDeclare as class attribute with no type specified:class Example:
    # This instantiates the descriptor for this class
    observable = ObservableAttribute()

    def __init__(self, anything, subscribed_function):
        # This calls the __set__ method of the descriptor:
        # - The descriptor instantiates 'hidden' proxy self._observable with 'anything' as the underlying object
        # - type(anything) is now the fixed type of self.observable
        self.observable = anything
        self.observable.subscribe(subscribed_function)Declare as class attribute with a fixed specified type:class Example:
    # This instantiates the descriptor for this class
    observable = ObservableAttribute(list)

    def __init__(self, value, subscribed_function):
        # This calls the __get__ method of the descriptor:
        # - The descriptor instantiates 'hidden' proxy self._observable with 'list()' as the underlying object
        self.observable.append(value)
        self.observable.subscribe(subscribed_function)