Saravanan666/pypi-org huggingface dataset:
Package: enigmamachine
# Enigma-Machine-LibaryThis library provides functions for simulating the Enigma Machine, a historical encryption device used during World War II. The library was created as part of an assessment for INSPER college in São Paulo, Brazil.Functions
The library includes the following functions:The following functions are part of an encryption/decryption system based on an enigma machine.to_one_hotConverts a string of letters into a matrix representation using one-hot encoding.Args:
message: str containing the letters to be encoded.Returns:
np.ndarray: matrix with one-hot encoding of the input message.to_stringConverts a matrix of one-hot encoded characters into a string of letters.Args:
matrix: np.ndarray containing the one-hot encoded characters.Returns:
str: string of letters corresponding to the input matrix.encryptEncrypts a message using a permutation matrix.Args:
message: str containing the message to be encrypted.
permutation_matrix: np.ndarray representing the permutation matrix to be used for encryption.Returns:
str: encrypted messagedecryptDecrypts an encrypted message using a permutation matrix.Args:
encrypted_message: str containing the message to be decrypted.
permutation_matrix: np.ndarray representing the permutation matrix to be used for decryption.Returns:
str: decrypted message.enigma_machineEncrypts a message using a permutation matrix and an auxiliary matrix.Args:
message: str containing the message to be encrypted.
permutation_matrix: np.ndarray representing the permutation matrix to be used for encryption.
auxiliary_matrix: np.ndarray representing the auxiliary matrix to be used for encryption.Returns:
str: encrypted message.enigma_machine_decryptDecrypts an encrypted message using a permutation matrix and an auxiliary matrix.Args:
encrypted_message: str containing the message to be decrypted.
permutation_matrix: np.ndarray representing the permutation matrix to be used for decryption.
auxiliary_matrix: np.ndarray representing the auxiliary matrix to be used for decryption.Returns:
str: decrypted message.Change Log0.0.2 (07/03/2023)First Release
Package: enigmapy
🐋 equitiesOverview:equities allows for easy access to the SEC's XBRL Financial Statement Dataset
Parsed data is stored locally and served to the user in pandas dataframesThe Dataset:https://www.sec.gov/dera/data/financial-statement-data-sets.htmlInstall:pip3 install equitiesDonate:Consider donating bitcoin to fund the future development of this project.bitcoin wallet address: 3LU5MEaAXRJoCo6vx67g1Jj7qDFRKhMs5tTUTORIAL:The library consists of two central objects, Universe and Company.Universe:Building the UniverseWe begin by initializing our universe and downloading our sec data packages.from equities import Universe
u = Universe()Essential MethodsTo get the number of companies in the universe call:
len(u)To get a dataframe of XBRL metadata from of all companies in the universe call:u.properties()"CIK" numbers are the sec's official unique identifier for public companies. To get a full list of the cik numbers call:u.ciks()Accessing CompaniesUniverse objects are indexable by "CIK" integers. As an example, to access the first company in the universe call:first_cik = universe.ciks()[0]
u[first_cik] # This returns an Company object.Company:A Company object should be thought of as an abstract representation of a real company. Every
company must have an associated Universe of origin.from equities import CompanyAccessing the Financial StatementsConsider the first Company in our universe, universe[u.ciks()[0]]. It is a Company object.c = u[u.ciks()[0]]Dataframes of the company's financial statements over the universe in question is given by:c.income()      # income statement dataframe

c.balance()     # Balancesheet dataframe

c.cash()        # Cash Flow Statement dataframe

c.equity()      # Consolidated Equity dataframeAdditional Company DetailsTo get the XBRL metadata for a given company as a pandas series call:c.properties()ExampleI really want to demonstrate the beauty of this dataset since this is often difficult when looking
at thousands of numeric datatables. Let's take a very naive peek by plotting various statements
as a kind of stacked timeseries.The following is a start to finish example of how one might plot the financial statements
of the first three companies in the universe.To perform this experiment, run the following:from equities import test
test()Here is the code that this function executes:import pandas as pd
from equities import Universe, Company
import matplotlib.pyplot as plt

u = Universe()
u.build()

k,f,s = 'bar',(20,10),True
for cik in u.ciks()[:3]:

    u[cik].income().T.plot(
        kind=k,
        figsize=f,
        stacked=s)

    u[cik].cash().T.plot(
        kind=k,
        figsize=f,
        stacked=s)

    u[cik].balance().T.plot(
        kind=k,
        figsize=f,
        stacked=s)

plt.show()
Package: enigma-sdk
The Enigma SDK helps developers build Python applications that integrate with Enigma Public. The SDK is available as a Python package you can install using pip:$ pip install enigma-sdkThe Python SDK simplifies app development in several important ways versus using the Enigma Public API directly via calls to HTTP endpoints:The SDK handles all HTTP requests for you. This includes automatic retries, connection pooling, and passing of API keys.It generates iterators automatically if pagination is required, and supports Python list slicing for easy access to resources.It provides a set of “convenience” methods to implement common tasks that would otherwise require multiple API calls.It returns responses as Python objects you can query using familiar object.attribute patterns, rather than navigating JSON hierarchies.
Package: enigma-simulator
Enigma SimulatorAn implementation of the Enigma machine in Python. Simulates a common 3-rotor machine
with the common 8 rotors and 3 reflectors.Wikipediahas a good overview. Project
inspired bythis video.The transformation of each letter is implemented as a product of permutations(Rejewski, 1980),
in this case 26x26 matrices. The transform,E, in this formulation, can
therefore be expressed as:wherePis the plugboard,L,MandRare the left, middle and right rotors
respectively,Uis the reflector andpis the cyclic permutation of the mapping of A
to B, B to C, etc.a,bandcare the rotations of each rotor as caused when a key
was pressed.Can be used to encrypt/decrypt messages ('X' was used to replace spaces) as such:fromenigma_simulator.enigmaimportEnigma# Encryptingenigma1=Enigma(["I","II","III"],[1,1,1],"B","AD",[0,0,0])enigma1.encrypt("HELLOXWORLD")# Returns "LOFUHZZLZOB"# Decryptingenigma2=Enigma(["I","II","III"],[1,1,1],"B","AD",[0,0,0])enigma2.encrypt("LOFUHZZLZOB")# Returns "HELLOXWORLD" back
Package: eniius
eniiusA program for processing neutron data in the tradition ofHomerandHorace,eniiusis a utility for
embedding neutron instrument information using (nx)spe files.AimsProper analysis of inelastic neutron scattering (INS) data requires taking the
instrument resolution function into account[1], and this in
turn requires particular information about the neutron spectrometer
(instrument) recording the data. Hitherto this information has been obtained
post-facto from the program(s) performing the resolution convolution.In the interest ofFAIR dataand
to improve usability, this information should be embedded in the raw datafiles
produced by the instrument, and the aim ofeniiusis to provide a utility for
just this purpose.FeaturesInstrument data is embedded in aNeXusdata
file as aNXinstrumentgroup.The embedded instrument is at a minimum enough to be imported intoHoracefor resolution calculation.eniiusalso has the facility to export this information asMcStasinstrument files for ray tracing simulations of
the resolution function, and can also import certain McStas instrument files
to embed in raw data files.Is compatible with theIBEXdata acquisition program as well as theMantiddata reduction suite.Has a GUI for visualising the instrument data.
Package: enijo-connector
Overview and Project StateThis project is currently in “dormant” development, and not (yet)
fit for any production use. Initial purpose of this project was
to collect points at university; Currently this project is
awaiting to be bestowed with a new purpose – Feel free to contact
me with regards to a future roadmap.All APIs are subject to change.How To BuildDistributionpipenv sync
pipenv run make distThis will place a distributable package into thedist/directory.
This package can further be published or installed withpip3.Documentationpipenv sync
pipenv run make docsThe documentation is then found in directorybuild/docs/Notes for DevelopmentSome parts of the source and documentation are auto-generated from other
source files.pipenv sync
pipenv run make generateThis will renew all generated source files after some changes have been
applied by a developer.In-Source NomenclatureTODOpoints at which there could be further development in order to
improve the performance, support more features, or increase
resilience.FIXMEthe issue discribed by that line MUST be fixed before this project
could be considered for submitting as Exercise 2 Topic 9 solution.
Package: enimda
Entropy-based image border detection algorithm: finds out if your image has
borders or whitespaces around and helps you to trim border providing whitespace
offsets for every side of a picture, supports animated GIFs.Algorithm (simplified)For each side of the image starting from top, rotating image counterclockwise
to keep side of interest on top:Get upper block 25% of image heightGet lower block with the same height as the upper oneCalculate entropy for both blocks and their differenceMake upper block 1px lessRepeat from p.2 until we hit image edgeBorder is between blocks with entropy difference maximumRequirementsPython 3.5+Setuppython-3.6-mvenv.envsource.env/bin/activatepipinstallenimdaUsageFind if image has borders:fromenimdaimportENIMDA# Load target imageem=ENIMDA(fp='test.jpg')# Scan for borders with high precisionborders=em.scan(fast=False)# Print found image borders (tuple): top, right, bottom, leftprint(borders)DemoFor demo please refer toENIMDA DemoAlso it lives atPicture Instrumentsas ‘Remove borders’
instrumentTestsRun tests: py.test
Package: enipy
Enipy toolThis is a python package used for data analysing and visualizing Lightning (https://en.wikipedia.org/wiki/Lightning) data provided by Earth Networks.
Earth Networks is a leader in locating and collecting Lightning data for over 20 years. Enipy python package is extremely beneficial
for Scientists and Engineers, who want to decode and use Earth networks Lightning data for research.The entire library is implemented using Cython (C extension for Python), which makes it very efficient to process Big data.If you have any questions about the package, please contact Micheal Stock (mstock@earthnetworks.com) and Jeff Lapierre (jlapierre@earthnetworks.com).
Package: eniris
Eniris API driver for PythonThis repository contains the official Eniris API driver for Python. This driver takes care of authentication as well as request retries and timeouts, in accordance with theauthentication API documentation. It offers users an interface which is inspired by the popularrequestslibrary.InstallationTo install the latest stable version, use:pipinstallenirisQuick ExamplefromenirisimportApiDriverdriver=ApiDriver("myUsername","myPassword")http_response=driver.get("/v1/device")response_body=http_response.json()print(response_body['device'][:10])driver.close()DetailsThe driver constructor accepts the following arguments:username (string, required)password (string, required)authUrl (string, optional, default: 'https://authentication.eniris.be'): URL of authentication endpointapiUrl (string, optional, default: 'https://api.eniris.be'): URL of api endpointtimeoutS (int, optional, default: 60): Request timeout in secondsmaximumRetries (int, optional, default: 5): How many times to try again in case of a failure due to connection or unavailability problemsinitialRetryDelayS (int, optional, default: 1): The initial delay between successive retries in seconds.maximumRetryDelayS (int, optional, default: 60): The maximum delay between successive retries in seconds.session (requests.Session, optional, default: requests.Session()): A session object to use for all API calls.Furthermore, the following methods are exposed:accesstoken: Get a currently valid accesstokenget/delete: Send a HTTP GET/DELETE request. The following parameters are allowed:path (string, required): Either a path relative to the apiUrl, or a full URL pathparams (dict, optional, default: None): URL query parameterspost/put: Send a HTTP POST or PUT request. The following parameters are allowed:path (string, required): Either a path relative to the apiUrl, or a full URL pathjson (dict, optional, default: None): JSON body of the request. The json argument and the data argument cannot both be different from Noneparams (dict, optional, default: None): URL query parametersdata (string or dict, optional, default: None): Payload of the request. The json argument and the data argument cannot both be different from None
Package: enjalice
EnjAliceEnjAlice - асинхронная обёртка над API Яндекс.Алисы, которая предоставляет возможность быстро запустить и удобно разрабатывать callback диалоги.Документация доступна по ссылке:https://enjalice.readthedocs.io/ru/latest/Установкаpip install enjaliceПример ботаВсе примеры находятся в папке /exampleCopyrightПроект имеет лицензию MIT.Copyright © Jotty
Package: en-john-ner
Feature | Description |— | — |Name|en_john_ner|Version|0.0.0|spaCy|>=3.5.4,<3.6.0|Default Pipeline|ner|Components|ner|Vectors| 0 keys, 0 unique vectors (0 dimensions) |Sources| n/a |License| n/a |Author| [n/a]() |### Label Scheme<details><summary>View label scheme (13 labels for 1 components)</summary>Component | Labels |— | — |`ner`|DATE,EDUC,EMAIL,LANG,NAT,ORG,PERSON,POSITION,SCHOOL,SKILL,SPECIAL,TECH,TELEPHONE|</details>### AccuracyType | Score |— | — |ENTS_F| 79.40 |ENTS_P| 81.86 |ENTS_R| 77.09 |NER_LOSS| 823637.17 |
Package: enjoy
enjoyPure python, concurrency agnostic, access to linux input system. Useful for controlling game pads, joysticksCommand line$ python -m enjoy.cli table
+---------------------------------+--------------------+-------------------------+
| Sony PLAYSTATION(R)3 Controller | /dev/input/event26 | SYN, KEY, ABS, MSC, FF  |
+---------------------------------+--------------------+-------------------------+
...


$ python -m enjoy.cli listen /dev/input/event26
X: 129 Y:126 Z:  0 | RX: 128 RY:128 RZ:  0 | EAST WESTAPIAPI not documented yet. Just this example:importtimefromenjoy.inputimportfind_gamepadspad=next(find_gamepads())abs=pad.absolutewithpad:whileTrue:print(f"X:{abs.x:>3}| Y:{abs.y:>3}| RX:{abs.rx:>3}| RY:{abs.ry:>3}",end="\r",flush=True)time.sleep(0.1)
Package: enjoyn
Welcome!Generate and animate images in parallel, enjoyably.Getting StartedInstallationInstallenjoynwithpip:pipinstallenjoynRequires an installation of Python 3.7+.ResourcesThe full documentation can be foundhere.If you encounter any bugs while usingenjoyn, feel free toopen an issue.If you have any questions or issues while usingenjoyn, ask away indiscussions!Don't forget to star the project if you like the project!
Package: enjoy-slurm
enjoy-slurmenjoy-slurmis a naive slurm control package for python. It does interact with Slurm exactly as any user would do, simply through the command
line tools and arguments. That's why we call itnaive. However, it should avoid having to rewrite some scripts required to submit and control many
Slurm jobs on an HPC computer. This package is a successor of the retiredHPC scheduler package.FeaturesUsesbatch,sacct,scontroletc. directly from python with a pythonic API.Parse command outputs into python objects like pandas DataFrames or dictionaries.Examplesimportenjoy_slurmasslurmjobid=slurm.sbatch("job.sh",partition="compute",account="my_account")acct=slurm.sacct(jobid=jobid)# run another job that depends on the firstjobid1=slurm.sbatch("another_job.sh",dependency=jobid,partition="shared",account="my_account")acct1=slurm.sacct(jobid=jobid1)Related projectspyslurmsimple_slurmipyslurmProject based on thecookiecutter science project template.
Package: enkacard
EnkaCardAn asynchronous module and API that allows you to connect to your bot the generation of Genshin character cards from the Enka.Network website.:white_medium_square:Documentation:white_medium_square:Telegram Bot:white_medium_square:Generation results:white_medium_square:StarRailCard:white_medium_square:Additional module:white_medium_square:AssetsInstallation:pip install enkacardLaunch:fromenkacardimportencbannerimportasyncioasyncdefcard():asyncwithencbanner.ENC(uid="811455610")asencard:returnawaitencard.creat()result=asyncio.run(card())print(result)Launch Profilefromenkacardimportencbannerimportasyncioasyncdefcard():asyncwithencbanner.ENC(uid="811455610")asencard:returnawaitencard.profile(card=True)result=asyncio.run(card())print(result)Update enkanetwork.py datafromenkacardimportencbannerimportasyncioasyncdefmain():awaitencbanner.update()result=asyncio.run(main())print(result)Aliternative method:ToolsLanguages SupportedLanguegeCodeLanguegeCodeLanguegeCodeEnglishenрусскийruChinesechsTiếng ViệtviไทยthTaiwanchtportuguêspt한국어krdeutschde日本語jp中文zhespañoles中文zhIndonesianidfrançaisfrKhaenri'ahkhKhaenri'ah
Package: enkacard2
EnkaCardAn asynchronous module and API that allows you to connect to your bot the generation of Genshin character cards from the Enka.Network website.5 templates to choose from.2 profile templates.Customization of all cards with background adaptation.Full Documentation:Documentation EnkaCard2ENCard- Addon to the module.NewVerisonInstallation:pip install enkacardLaunch:fromenkacard2importencbanner2importasyncioasyncdefcard():asyncwithencbanner2.ENC((uid="811455610")asencard:returnawaitencard.creat(1)result=asyncio.run(card())print(result)Launch Profilefromenkacard2importencbanner2importasyncioasyncdefcard():asyncwithencbanner2.ENC(uid="811455610")asencard:returnawaitencard.profile(1)result=asyncio.run(card())print(result)Languages SupportedLanguegeCodeLanguegeCodeLanguegeCodeEnglishenрусскийruChinesechsTiếng ViệtviไทยthTaiwanchtportuguêspt한국어krdeutschde日本語jp中文zhespañoles中文zhIndonesianidfrançaisfrSample Results:Sample 1 templateSample 2 templateSample 3 templateSample 4 templateSample 5 templateSample 6 templateSample 7 templateProfile sample 1 templateProfile sample 2 templateThank the author for the code:Patreon:https://www.patreon.com/deviantapi
Package: enkie
ENKIE - The ENzyme KInetics EstimatorENKIE is a python package for the prediction of kinetic parameter values and
uncertainties in metabolic networks. The package uses Bayesian Multilevel Models to
predict values and uncertainties from reaction, protein and metabolite identifiers. The
predictions are then combined with standard free energy estimates to ensure
thermodynamic consistency.InstallationENKIE is available as a Python package on thePython Package
Index, see thedocumentationfor the installation instructions.Cite usIf you use ENKIE in a scientific publication, please cite our paper:Gollub, M.G., Backes, T., Kaltenbach, H.M., Stelling, J., 2023. "ENKIE: A package for
predicting enzyme kinetic parameter values and their uncertainties".bioRxiv. -DOI
Package: enkonix-django-dynamodb-cache
django-dynamodb-cacheFast, safe, cost-effective DynamoDB cache backend for Djangodjango-dynamodb-cacheIntroduceWhy should I use this?InstallationSetup on DjangoAws credentialsCreate cache table commandHow to contributeIntroduceThis project is a cache backend using aws dynamodb.This is compatible with the django official cache framework.Did you set the boto3 permission?Enter the django official command createcachetable and get started easily.Why should I use this?There are few management points, because dynamodb is a fully managed service.Data is safely stored unlike inmemory db.Because you only pay for what you use, it saves money on light projects such as side projects or back offices.If you need more performance, you can easily switch to DAX.Installationpipinstalldjango-dynamodb-cacheSetup on DjangoOn Djangosettings.pyINSTALLED_APPS=[..."enkonix_django_dynamodb_cache"]CACHES={"default":{"BACKEND":"enkonix_django_dynamodb_cache.backend.DjangoCacheBackend","LOCATION":"table-name",# (mandatory)"TIMEOUT":120,# (optional) seconds"KEY_PREFIX":"enkonix_django_dynamodb_cache",# (optional)"VERSION":1,# (optional)"KEY_FUNCTION":"path.to.function",# (optional) f"{prefix}:{key}:{version}""OPTIONS":{"aws_region_name":"us-east-1",# (optional)"aws_access_key_id":"aws_access_key_id",# (optional)"aws_secret_access_key":"aws_secret_access_key",# (optional)"is_on_demand":False,# (optional) default: True"read_capacity_units":1,# (optional)"write_capacity_units":1,# (optional)"encode":"enkonix_django_dynamodb_cache.encode.PickleEncode"# (optional)}}}Aws credentialsThe same method as configuring-credentials provided in the boto3 documentation is used.https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentialsCreate cache table commandRun manage command to create cache table on Dynamodb before usingpythonmanage.pycreatecachetableHow to contributeThis project is welcome to contributions!Please submit an issue ticket before submitting a patch.Pull requests are merged into the main branch and should always remain available.After passing all test code, it is reviewed and merged.
Package: enkonix-wagtail-localize
Wagtail localizeWagtail Localize is a translation plugin for theWagtail CMS. It allows pages or snippets to be translated within Wagtail's admin interface. It also provides integrations with external translations services such asPontoonorDeepL, and importing/exporting translations with PO files.DocumentationChangelogRequirementsWagtail Localize requires the following:Python (3.7, 3.8, 3.9, 3.10)Django (2.2, 3.0, 3.1, 3.2, 4.0)Wagtail (2.11, 2.12, 2.13, 2.14, 2.15, 2.16, 3.0) withinternationalisation enabledInstallationInstall usingpip:pipinstallwagtail-localizeAddwagtail_localizeandwagtail_localize.localesto yourINSTALLED_APPSsetting:INSTALLED_APPS=[# ..."wagtail_localize","wagtail_localize.locales",# This replaces "wagtail.locales"# ...]ContributingAll contributions are welcome!InstallTo make changes to this project, first clone this repository:gitclonegit@github.com:wagtail/wagtail-localize.gitcdwagtail-localizeWith your preferred virtualenv activated, install testing dependencies:pipinstall-e.[testing]-Upre-commitNote that this project usespre-commit. To set up locally:# if you don't have it yet, globally$pipinstallpre-commit# go to the project directory$cdwagtail-localize# initialize pre-commit$pre-commitinstall# Optional, run all checks once for this, then the checks will run only on the changed files$pre-commitrun--all-filesHow to run testsNow you can run tests as shown below:toxor, you can run them for a specific environmenttox -e python3.8-django3.2-wagtail2.15or specific testtox -e python3.9-django3.2-wagtail2.15-sqlite wagtail_localize.tests.test_edit_translation.TestGetEditTranslationViewTo run the test app interactively, usetox -e interactive, visithttp://127.0.0.1:8020/admin/and log in withadmin/changeme.SupportFor support, please useGitHub Discussionsor ask a question on the#multi-languagechannel onWagtail's Slack instance.ThanksMany thanks to all of our supporters, contributors, and early adopters who helped with the initial release. In particular, to The Mozilla Foundation and Torchbox who sponsored the majority of the initial development and Wagtail core's internationalisation support.