Saravanan666/pypi-org huggingface dataset:
Package: essentialdb
For Python 3.4, 3.5, 3.6 & 3.7(Nightly)EssentialDB is a pure Python document database developed to meet the following tenets:Databases shouldn’t slow down development - a developer should be able to integrate a database in less than a minute.Development databases should have a complete feature set and be performant enough for prototyping and project startupsDevelopment databases should provide a path to scale when your project takes offProject On GitHub|Full Docs @ ReadTheDocs|Distribution On PypiSpeeding DevelopmentOur first tenet is that you should be able to start developing in less than a minute. Since EssentialDB is an ‘embedded’ database, there is no external services or dependencies to install or administrate. The tenet here is to take you from concept to development in less than a minute.Installing is this simple:pip install essentialdbUsing is this simple:from essentialdb import EssentialDB

#create or open the database
db = EssentialDB(filepath="my.db")

#get the collection using 'adhoc' style (like pymongo)
authors = db.authors

#get the collection explicitly
authors = db.get_collection('authors', create=True)

#insert a document into the collection
authors.insert_one({'first': 'Langston', 'last': 'Hughes', 'born': 1902});

#find some entries
results = authors.find({'last':'Hughes'})

#commit the changes to disk
db.sync()You can also use with semantics to assure that the database is closed and synced on exit:with EssentialDB(filepath="my.db").authors as authors:

    data = [{'first': 'Langston', 'last': 'Hughes', 'born': 1902},
    {'first': 'Ezra', 'last': 'Pound', 'born': 1885}]

    authors.insert_many(data)Documents are just Python dictionaries and EssentialDB provides an API to easily store and retrieve them.Features & PerformanceOur second tenet is that EssentialDB should have the performance and features you need to get your project rolling.EssentialDB supports a very rich queries that follow the same basic form as MongoDB:{ <field1>:  <operator1>: <value1> }, ... }Most comparison operators are supported, including equals, not equals,  less than, greater than:author_db.find({"born" : {"$gt": 1900}})You can even test against lists of items using $in and $nin:author_db.find({"genre" : {"$in": ["tragedy", "drama"]}})AND and OR boolean operators allow you to make arbitrarily complex queries:#find authors born after 1900 and before 2000
author_db.find({'$and':[{'born': {'$gte': 1900}},{'born': {'$lt': 2000}}]})

#find authors with either the first or last name John
author_db.find({'$or':[{'first': {'$eg': 'John'}},{'last': {'$eq': 'John'}}]})We’ve tested EssentialDB under some typical use cases, and seen that it is plenty performant for many use cases with small to moderate loads.
Package: essential-helpers
🧹 Essential Helpers 🧹Installpipinstallessential-helpersUsageimportess_helpersArgument ParsingUses the argparse built-in module to parse arguments ran alongside your script.Assign your argsfromessential-helpers.argumentsimportArgumentParserparser=ArgumentParser()# Stringsstring_arg:tuple=("-s","--string-example")string_help:str="This is an example string argument, pass in a string after this argument."parser.add_string_argument(string_arg,string_help)# Intsint_arg:str="-i"int_help:str="This is an example int argument, pass in an int after this argument."parser.add_int_argument(int_arg,int_help)# Boolsbool_arg:frozenset={"-b","--bool"}bool_help:str="This is an example bool argument, passing this will set this bool to true."parser.add_bool_argument(bool_arg,bool_help)*You can pass in a str ("-eg") or a tuple/list/set (["-eg", "--example"])Reference them to see if they have been passed in and what values they holdstring_value:str=parser.get_arg("s")int_value:int=parser.get_arg("int")is_bool:bool=parser.get_arg("bool")all_args:dict=parser.get_all_args()string_value:str=all_args.get("s")int_value:int=all_args.get("int")is_bool:bool=all_args.get("bool")EncryptionShell ExecutionFile Management
Package: essential-pathway
Quick LinksProject <https://github.com/realasking/essential-pathway>Author’s Homepage <https://realasking.wordpress.com>Author’s Emails <realasking@gmail.com,tomwangsim@163.com>Manual of Environment Modules <http://modules.sourceforge.net/tcl/module.html>IntroductionEssential-pathway (short for ep) is a tool that helps people quickly access to their most commonly used folders in command line in some
operation systems like linux. A PATHWAY is defined as a user named environment variable using this tool, which consists of a pathway name, a path and a comment.
One can add, modify or delete PATHWAYS which linked to their folders’ paths, or do some comments for memory.This tool has only been tested in archlinux and might not be able to use under root. It’s based on Environment Modules (short for em) and is released under LGPLv3.DependenciesThe native Tcl version Environment Modules package is needed by this tool, while a $HOME/.modulespath with a contained user modulefiles folder
should also be created by user before using ep.An example of $HOME/.modulespath:<br>`bash modules `And a folder name modules should be created in $HOME/After that, the following sentences must be add to $HOME/.bashrc to keep em works properly:<br>`bash exportMODULEPATH=${HOME}/modules:$MODULEPATH<br> source/etc/modules-tcl/init/bash<br>`Prettytable, an elegant table processing python library is also needed.Ep can be installed when all dependencies are met.Installation`bash git clonehttps://github.com/realasking/essential-pathway.gitcdessential-pathwaysudo python ./setup.py install `Or you can use pip`bash pip installessential-pathway`UsageNotice:<br>
Before each operations below, please execute 'module unload epath' first.<br>
To make pathways usable, please execute 'module load epath' or add this sentence to $HOME/.bashrc.<br>
'ep u' just delete epath, and will keep the database file in $HOME/.ep.Quckly add current foler to a pathway<br>`bash ep a PATHWAY_NAME `Listing exsit pathways<br>`bash ep l `Create a pathway<br>`bash ep a PATHWAY_NAME PATH_TO_YOUR_FOLDER `Make or change a short comment for an exists pathway<br>`bash ep c PATHWAY_NAME `Modify a pathway<br>`bash ep m PATHWAY_NAME PATH_TO_NEW_FOLDER `Delete a pathway<br>`bash ep d PATHWAY_NAME `Check paths’ availabilities and automatic delete invalid ones<br>`bash ep k `Refresh the Env-module<br>`bash ep r `Backup settings<br>`bash ep b `Uninstall all settings<br>`bash ep u `When the module epath has been loaded, one can use “$PATHWAY_NAME” instead of the whole path, the “” pair cannot be omitted if there are blank spaces in the path.realasking
Aug 15,2017
changlog
——–
2017-08-24 Released 1.0.2. Fix bugs.
2017-08-23 Modified ep to keep module file epath unloaded before ep start.
2017-08-15 Finished debuging and testing in 64bit linux, and publish version 1.0
2017-08-06 All scripts have been rewritten by using python3
2017-07-23 Begins to arrange older scripts I wrote to manage massive folders’ paths
Package: essential-paxos
Essential Paxos provides basic implementations of the Paxos algorithm. The
distinguishing characteristic of this implementation, as compared to other
freely available and open-source implementations, is that this library is
independent of application domains and networking infrastructures. Whereas most
Paxos implementations are deeply and inextricably embedded within
application-specific logic, this implementation focuses on encapsulating the
Paxos algorithm within opaque and easily re-usable classes.This library provides an algorithmically correct Paxos implementation that may
be used for educational purposes in addition to direct use in networked
applications. This implementation is specifically designed to facilitate
understanding of both the essential Paxos algorithm as well as the practical
considerations that must be taken into account for real-world use.
Package: essentials
EssentialsCore classes and functions, reusable in any kind of Python application.$pipinstallessentialsFeatures:exception classes to express common scenariosfriendly JSON encoder, handlingdatetime,date,time,UUID,bytes, built-in enums, and instances of classes implementing adict()method, likepydantic BaseModelutilities to work withfoldersand pathsStopWatchimplementationa base class to handle classes that can be instantiated from configuration dictionariescommon decorator to support retriescommon decorator to support logging function callscommon decorator to control raised exceptionscaching functionsDocumentationPlease refer to documentation in the project wiki:https://github.com/Neoteroi/essentials/wiki.Develop and run tests locallypipinstall-rrequirements.txt# run tests using automatic discovery:pytest# with code coverage:maketestcov
Package: essentials-configuration-keyvault
essentials-configuration-keyvaultAzure Key
Vaultsource foressentials-configuration.pipinstallessentials-configuration-keyvaultessentials-configurationprovides a way to handle configuration roots
composed of different layers, such as configuration files and environmental
variables. Layers are applied in order and can override each others' values,
enabling different scenarios like configuration by environment (e.g. DEV, TEST,
PROD) and system instance.essentials-configuration-keyvaultprovides a solution to add secrets stored
in Azure Key Vault into configuration objects.Example:fromazure.identityimportDefaultAzureCredentialfromazure.keyvault.secretsimportSecretClientfromconfig.commonimportConfigurationBuilderfromconfig.keyvaultimportKeyVaultSourcekey_vault_name="example-keyvault-name"secrets_client=SecretClient(vault_url=f"https://{key_vault_name}.vault.azure.net",credential=DefaultAzureCredential(),)builder=ConfigurationBuilder(KeyVaultSource(secrets_client))# when the configuration object is built, secrets are fetched from# the linked key vault and put into the configuration object (e.g.# database connection strings, API keys for SendGrid, etc.)config=builder.build()Refer to theofficial Key Vault documentation for more
information about its Python client library..How to run the tests using a real Key VaultThe provided tests can either use a mockedSecretClient, or use a real Key Vault.
To use a real Key Vault service:create a Key Vault (ref.)sign-in using any way supported byazure.identity.DefaultAzureCredential3
(e.g. VS Code oraz login)run the tests with the following command:KEYVAULT_NAME="<YOUR_KEYVAULT_NAME>"pytest-s
Package: essentials-openapi
essentials-openapiClasses to generateOpenAPI Documentationv3 and v2, in JSON and YAML, and to generate other kinds of documents from
OpenAPI Documentation files.pipinstallessentials-openapiTo install with dependencies to generate other kinds of artifacts from source
OpenAPI Documentation files:pipinstallessentials-openapi[full]Useful linkshttps://swagger.io/specification/https://editor.swagger.ioUsageThis library has been originally created to implement generation of OpenAPI Documentation
in theBlackSheepweb framework.
However, this package is abstracted from that web framework and can be reused for other
applications. Today this library also offers functions to generate documentation from
source OpenAPI Documentation files.Features to generate artifacts from Open API DocumentationThese require the full package: install it usingpip install essentials-openapi[full].To generate output forMkDocsandPyMdown extentions:oadgen-docs-sexample1-openapi.json-doutput.mdExample of MkDocs documentation generated usingNeoteroi/mkdocs-plugins.To generate aPlantUMLclass
diagramof the components schemas:oadgen-docs-ssource-openapi.json-dschemas.wsd--style"PLANTUML_SCHEMAS"Example of PlantUML diagram generated from components schemas.To generate aPlantUMLclass
diagramwith an overview of API endpoints:oadgen-docs-ssource-openapi.json-dschemas.wsd--style"PLANTUML_API"Example of PlantUML diagram generated from path items.GoalsProvide an API to generate OpenAPI Documentation files.Providing functions to handle OpenAPI Documentation, like those to generate
other kinds of documentation from source OpenAPI Documentation files.Support enough features to be useful for the most common API scenarios,
especially for OAD files that are generated automatically from web frameworks.Non-GoalsTo implement the whole OAD Specification.For the features that generate artifacts: OpenAPI Documentation files aresupposed to be coming from trusted sources. Trying to handle source files
from untrusted sources and potentially causing HTML injection is out of the
scope of this library.LimitationsPartial support for Parameter properties:style,allow_reserved,explodeare not
handled.Doesn't implement validation of values, currently it is only concerned in generating
code from a higher level API (it might be extended in the future with classes for
validation).The features to generate artifacts from OpenAPI Documentation currently support only
Version 3 of the specification.StylesStyleInt valueDescriptionMKDOCS1Markdown for MkDocs and PyMdown extensions.MARKDOWN2Basic Markdown.HTML3Plain HTML(planned, not yet implemented).PLANTUML_SCHEMAS100PlantUML schema for components schemas.PLANTUML_API101PlantUML schema for API endpoints.Supported sources for OpenAPI DocumentationSourceExampleYAML file./docs/swagger.yamlJSON file./docs/swagger.jsonURL returning YAML on HTTP GEThttps://example-domain.net/swagger/v1/swagger.yamlURL returning JSON on HTTP GEThttps://example-domain.net/swagger/v1/swagger.json
Package: essentialsx
Python EssentialsEasily create a logger enhanced withrich logging handlerTraceback formatting that you can easily following viarich TracebackNon-blocking hotkey monitoring viakeyboard(e.g. enable debug logging on the fly)Example UsageInstallingessentialsxis registered on pypi and can be installed via pippipinstallessentialsxBasic SetupfromessentialsximportEssentialsessentials=Essentials()LoggingA simple wrapper for creating a logger (uses built-inloggingmodule) was created which also adds in therich logging handlerfor a beautiful logging experience. A couple optional parameters exist for this wrapper:ParameterFunctionalitynameThe name space to use for the logger. Uses root by default.logfileCreates a file handler at this path and logs entries to this file in addition to the console handler.loglevelThe loglevel to be used (INFO, DEBUG, WARNING, ERROR, CRITICAL). Uses INFO by default.# Create a basic logger with console handlerlog=essentials.get_logger()log.info('Logging to console works!')# Create a logger with log file handlerlog=essentials.get_logger(logfile='/tmp/logfile.log')log.info('Logging to console and file works!')HotkeysThere are a few wrapper functions for thekeyboardhotkey functions, this is to help keep track of hotkeys in use which gives us the opportunity to provide some predefined hotkeys. Hotkeys will need to be registered via theregister_hotkey()function and will not be active (including the predefined hotkeys) until theenable_hotkeys()function is called. To disable hotkeys once they have been enabled, simply call thedisable_hotkeys()function.Predefined HotkeysHotkeyFunctionalityctrl+alt+dToggles debug log levelctrl+alt+lLists all registered hotkeysRegistering Hotkeys# Register a function with no argumentsdeffoo():print('bar')essentials.register_hotkey('ctrl+f',foo)>>bar# Register a function with argumentsdefbar(baz):print(baz)essentials.register_hotkey('ctrl+b',bar,args=('baz',))>>bazNote: Registered hotkeys aren't active untilenable_hotkeys()is called.Enabling / Disabling Hotkeys# Enable all registered hotkeysessentials.enable_hotkeys()# Disable all enabled hotkeysessentials.disable_hotkeys()
Package: essentia-tensorflow
Essentia is an open-source C++ library with Python bindings for audio analysis and audio-based music information retrieval. It contains an extensive collection of algorithms, including audio input/output functionality, standard digital signal processing blocks, statistical characterization of data, a large variety of spectral, temporal, tonal, and high-level music descriptors, and tools for inference with deep learning models. Designed with a focus on optimization in terms of robustness, computational speed, low memory usage, as well as flexibility, it is efficient for many industrial applications and allows fast prototyping and setting up research experiments very rapidly.Website:https://essentia.upf.edu
Package: esser
[![pypi version](https://img.shields.io/pypi/v/esser.svg)](https://pypi.python.org/pypi/esser)
[![pypi package](https://img.shields.io/pypi/dm/esser.svg)](https://pypi.python.org/pypi/esser)
[![Build Status](https://travis-ci.org/geeknam/esser.svg?branch=master)](https://travis-ci.org/geeknam/esser)
[![Coverage Status](https://coveralls.io/repos/github/geeknam/esser/badge.svg?branch=master)](https://coveralls.io/github/geeknam/esser?branch=master)
[![Code Issues](https://www.quantifiedcode.com/api/v1/project/2644f358dc5246da951352fb0550f84f/badge.svg)](https://www.quantifiedcode.com/app/project/2644f358dc5246da951352fb0550f84f)
[![Slack](https://img.shields.io/badge/chat-slack-ff69b4.svg)](https://esser-py.slack.com/)Serverless + Pay-As-You-GoAggregatesSnapshotsProjectionsRuntimeAWS Lambda PythonEvent StoreThe primary data store used for writes isDynamoDBSnapshoting can be achieved viaDynamoDBstreamsQuery StoreAggregates should be queried using a different store.
Available strategies for storing materialsed views:PostgreSQLElasticsearchRedisAWS Lambda can pull changes from DynamoDB stream and update the
query models.
Package: essHIC
essHICA python package to analyze Hi-C matrices, enhance their specific patterns through spectral filtering and compute metric distances between couples of experiments.You may find the github repository athttps://github.com/stefanofranzini/essHICessHIC contains many useful modules to guide users throughout the analysis:essHIC.makehic: enables the user to process raw matrix data and their metadata to merge multiple sources into a single well ordered data repository, split chromosomes and obtain Observed over Expected matrices if needed.essHIC.hic: wrapper class for Hi-C matrices containing metadata along with the matrix of contact probabilities for the chosen experiment. It contains useful tools
to normalize and clean the matrix, compute its spectral properties, and process it to obtain its essential component. It also provides plotting functions to
obtain high quality pictures with minimal knowledge of the matplotlib library.essHIC.ess: tool to compute a dataset-wide distance matrix between all couples of experiments using the essential metric distance.essHIC.dist: a useful explorative tool to analyze distance matrices. It allows to perform hierarchical and spectral clustering on the dataset, to compute the ROC curves according to the cell-types provided in the metadata, and to perform multiscaling dimensional reduction (MDS). It also contains plotting tools to visualize
the results of all mentioned analyses.More information is available on the packagewiki.INSTALLINGessHIC is written in python, it has been tested in python2.7. Both the python3 language and the required packages need to be installed. To install the package through the python package manager, copy and paste the snippet below in your terminal:pipinstall--upgradeessHICPlease notice that you may need to have administrator priviliges in order to be able to install the package. Using this method will take care of the dependencies.Otherwise, you may simply clone this repository to your computer. To use the package in a python script you will need to link its local path; to do so write the snippet below in your python code:importsyssys.path.append('path/to/essHIC')importessHICForessHICto function correctly you will need to install the required dependencies:numpy
scipy
sklearn
matplotlibUSAGETo useessHICin one of your python scripts import the package withimportessHICfor more information on how to use essHIC, please refer to thetutorialon the packagewiki
Package: essm
This package contains helpers to deal with physical variables and units.The documentation is available onhttps://essm.rtfd.io/.The quick installation for impatient users can be done by running:pip install essmChangesv1.1released 2020-12-20Featuresutils:Enable supplementary_imports in VariableWriter and EquationWriter
(PR #84)v1.0.1released 2020-11-05Bug Fixesglobal:Allow dimensionless variables in functions
(PR #94)v1.0.0released 2020-09-24Bug Fixesutils:Update code to work with isort5
(PR #89)Featuresglobal:Refactor code to work with sympy>=1.6
(PR #90)v0.4.3released 2020-06-18Bug Fixesutils:Include expr in variable definitions when writing to file
(PR #87)Featuresdocumentation:Add use examples as Jupyter notebooks and integrate in documentation
(PR #83)utils:Enable writers of .py files for re-import of variable and equation definitions
(PR #84)v0.4.2released 2020-04-28Bug Fixesutils:Improve markdown representation of units (PR #79)variables:Fix generate_metadata_table for selected variables (PR #80)v0.4.1released 2019-11-20Bug Fixesequations:Improve dimensional testing of equations and substitution (PR #73)equations:Add support for Integral and Piecewise in Equation PR (PR #76)Featuresutils:subs_eq() for simultaneous substitutions.(PR #75)v0.3.0released 2019-04-09Bug Fixesequations:improve substitutions with equations
(79ac37d)Featuresutils:add definition to metadata table
(3ceaa69)v0.2.0released 2019-04-04global: adapt to Python 3 and Sympy >=1.3global: removal of SageMath mentionsdocs: fix latex representation of x_O2 as x_{O2}equations: extend replace_variablesequations: make .subs() on equation return an equalityunits: reverted missing dimension lookupvariables: behave as Symbolsvariables: better markdown formatting of unitsvariables: changes base class to Symbolvariables: enableddictionaries with symbols in replace_variablesvariables: fix derive_unit for dimensionless expressionvariables: fix latex renderingvariables: generate_metadata_table with HTMLvariables: include assumptions from cls attributevariables: modify derive_unit to work with summationsvariables: remove Dimension deprecation warningsvariables: remove internal SI and refer to sympy.physics.units.systems.sivariables: respect unit in variable with exprvariables: set dimension and scale factor using methodvariables: support dimensionless variable expressionvariables: support replacing variables by their default valuesv0.1.0released 2017-06-29Initial public release.