Saravanan666/pypi-org huggingface dataset:
Package: extfslib
Midnight Commander extfslib helper library for writing extfs archive plugins.DescriptionExtfslib help with building Midnight Commander extfs plugins, especially for
those which operates on different kind of archives.Simplest plugin built on top of this lib would be:importextfslibclassMyArchive(extfslib.Archive):ARCHIVER="fancyarch"deflist(self):ifnotself._contents:return1foriteminself._contents:sys.stdout.buffer.write(self.ITEM%item)arch=MyArchive('/path/to/file.fancyarch')arch.list()In this example class instance should be able to be called withlistmethod.  All methods:listcopyincopyoutrmmkdirrmdirrunshould be implemented if needed, since by default all of them are just defined,
but not implemented.Of course, real life example can be a little bit more complicated, since there
would be possible need for adaptingLINE_PATwhich is regular expression
for getting attributes for the list compatible with MC along with theITEMwhich holds the output pattern and utilizes dictionary fromLINE_PAT,CMDwhich maps between class and archiver commands. Possibly there might be
needed some other adjustments.Additionally there is an optionalConfigclass, which might be used for
reading Midnight Commander ini file (ususally located in~/.config/mc/ini),
so that for the example above:importextfslibclassMyArchive(extfslib.Archive):ARCHIVER="fancyarch"def__init__(self):super().__init__()self.conf=extfslib.Config(self)ifself.conf,getint('config_key'):# do somethingwhere theiniconfig file would contain:…[myarchive]config_key=300…So, section name[myarchive]must match class name in lower case, and name
of the option is arbitrary string folowed by value. Note, the section and
options must be added manually.InstallationInstall from Pypi#pipinstallextfslibor, as a user:$pipinstallextfslib--useror use virtualenv:$gitclonehttps://github.com/gryf/mc_extfslib$cdmc_extfslib$virtualenvvenv$sourcevenv/bin/activate(venv)$pipinstallLicenseThis software is licensed under 3-clause BSD license. See LICENSE file for
details.
Package: exthread
Supercharged (sensible) execption propogating and lightweight
wrapper around the standard library Thread. Basically ensures
that you don’t have to perform cartwheels just to ensure that
the execution of your threaded tests/programs do not fail behind
your back with some exception. Usage example:>>>fromexthreadimportExThread>>>deftask():arr=[1,2,3]arr[4]>>>t=ExThread(task)>>>t.start()>>>t.join()Traceback(mostrecentcalllast):...IndexError:...The API is deliciously simple:>>>deftask(a,b=1):return[a,b]>>>t=ExThread(task,(1,),dict(b=2))>>>t.start()>>>t.join()[1,2]>>>assertt.errisNone>>>assertt.val==[1,2]You don’t really need it.But you want it.
Package: extinfo
Given a file extension, extinfo will scrape web sources for information about
what type of file is usually named with that extension.If you want to know what’s in an actual file you have on disk, you should use
the file command or another tool that leverages libmagic.Installationpip3 install extinfoUsage$extinfojpeg|fmtFrom https://fileinfo.com/extension/jpeg#JPEGImageA JPEG file is an image saved in a compressed graphic format standardized
by the Joint Photographic Experts Group (JPEG). It supports up to 24-bit
color and is compressed using lossy compression, which may noticeably
reduce the image quality if high amounts of compression are used. JPEG
files are commonly used for storing digital photos and web graphics.#WhatisaJPEGfile?JPEG file open in Microsoft Windows Photos

In the early 1980s, no technology existed that allowed users to easily
compress and share digital images with one another. In 1982, the JPEG
workgroup began designing a compression standard that could be used to
reduce image files' size, making them easier to share, while retaining
as much of their quality as possible.

In 1992, the workgroup created the JPEG file format. JPEG files are images
created using a lossy compression algorithm, which actually destroys some
data contained within the original image file. However, this data loss is
mostly unnoticeable to the human eye. Because the JPEG standard continues
to allows users to produce sharable, high-quality image files, and because
it is so embedded within technologies used to create and share images,
it is still the most common image compression standard in use today.

NOTE: A JPEG file also contains metadata that describes the contents of
its file, such as the color space, color profile, and image dimension
information. Image files saved in the JPEG format are more commonly
appended with the .JPG extension than the JPEG extension.DevelopmentTo install development dependencies, you will needpoetryandpre-commit.pre-commit install --install-hooks
poetry install && poetry shelldirenvis optional, but recommended for convenience.
Package: extism
Extism Python Host SDKThis repo contains the Python package for integrating with theExtismWebassembly framework. Install this library into
your Python application host to run Extism WebAssembly guest plug-ins.importextismimportjsonmanifest={"wasm":[{"url":"https://github.com/extism/plugins/releases/latest/download/count_vowels.wasm"}]}withextism.Plugin(manifest,wasi=True)asplugin:wasm_vowel_count=plugin.call("count_vowels","hello world",parse=lambdaoutput:json.loads(bytes(output).decode('utf-8')))print(wasm_vowel_count)# {'count': 3, 'total': 3, 'vowels': 'aeiouAEIOU'}InstallationInstall this package fromPyPI:# using pip$pipinstallextism==1.0.0# using poetry$poetryaddextism=^1.0.0Theextismpackage should install an appropriateextism_sysdependency
containing a prebuilt shared object for your system. We support the following
targets:MacOS 11.0+,arm64MacOS 10.7+,x86_64Manylinux 2.17+,aarch64Manylinux 2.17+,x86_64MUSL Linux 1.2+,aarch64Windows (MSVC),x86_64If you need support for a different platform or architecture, pleaselet us know!DocumentationCheck out the docs:Getting StartedAPI docsDevelopmentLocal devInstalljust. Runningjust testshould install all
other prerequisites.Release workflowCreate a semver-formatted git tag (git tag v1.0.0).Push that tag to the repository (git push origin v1.0.0.)Wait forthe Build workflow to run.Once the build workflow finishes, go to thereleasespage. You should
see a draft release.Edit the draft release. Publish the release.Wait forthe Release workflow to run.Once the release workflow completes, you should be able topip install extism==${YOUR_TAG}from PyPI.LICENSEBSD-3-Clause
Package: extism-func-gen
func-genfunc-gen can be used to generate unix text processing utilities from English text.
It useslangchainto create javascript functions
to process text, and it usesExtismand theJavaScript PDKto safely execute the code in a Wasm sandbox.InstallNote: First you need toinstall Extismon your machine if you have not:pipinstall--upgradeextism-func-genRun# Need to set the OpenAI API keyexportOPENAI_API_KEY="sk-<paste-key-here>"# Create a funcfunc-gencount_vowels-d"Write a function that counts the number of vowels in an input string"# Use a funcecho"hello world"|func-gencount_vowels# 3# List the funcsfunc-gen--list
Package: ext-list
ExtListThis library was created to improve the quality of code through list operations. It allows commonly written list comprehension operations to be called as methods and enables lists to be treated more abstractly than the built-inlist.Using this library reduces the number of times list comprehensions need to be written, resulting in improved overall code readability and searchability.More information ->Docs: ExtListInstallationpip install ext-listExamplesBelow are some examples of features of this library.Note: In the following examples, thePersonclass is defined as follows.(class Person)>>> class Person:
...     def __init__(self, name, age):
...         self.__name = name
...         self.__age = age
...
...     def introduce(self):
...         return f'{self.name} is {self.age} years old.'
...
...     def get_age_n_years_ago(self, n: int) -> int:
...        return self.age - n
...
...     @property
...     def name(self):
...         return self.__name
...
...     @property
...     def age(self):
...         return self.__age
...
...     def __repr__(self):
...         return f'Person(\'{self.name}\', {self.age})'
...Extract values>>> person_dicts = ExtList([{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}])
>>> person_dicts.extract('name')
['Alice', 'Bob']

>>> persons = ExtList(Person('Alice', 25), Person('Bob', 30))
>>> persons.extract(Person.name)
['Alice', 'Bob']

>>> persons.extract('name')
['Alice', 'Bob']

>>> persons.extract(Person.introduce)
['Alice is 25 years old.', 'Bob is 30 years old.']

>>> persons.extract(Person.get_age_n_years_ago, 5)
[20, 25]Get matched objects>>> persons = ExtList([{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}])
>>> persons.equals('name', 'Alice')
[{'name': 'Alice', 'age': 25}]

>>> persons = ExtList(Person('Alice', 25), Person('Bob', 30))
>>> persons.equals(Person.name, 'Alice')
[Person('Alice', 25)]

>>> persons.equals(Person.introduce, 'Bob is 30 years old.')
[Person('Bob', 30)]Convert list to dict>>> persons = ExtList([Person('Alice', 25), Person('Bob', 30)])
>>> persons.to_dict(Person.name)
{'Alice': Person('Alice', 25), 'Bob': Person('Bob', 30)}Convert list to dict with complex keys>>> persons = ExtList([Person('Alice', 25), Person('Bob', 30)])
>>> persons.to_dict_with_complex_keys([Person.name, Person.age])
{('Alice', 25): Person('Alice', 30),
('Bob', 30): Person('Bob', 25)}See theDocs: ExtListfor more examples !requirementstyping_extensionsLicenseMIT licenseAuthorSakaguchi Ryo (@GuriTech)
Package: extmath
Extended Mathextmath(formerlymathapi) aims to provide a lightweight & independent
extended mathematical module for Python 3.Avalable FeatureInfinite Number Setsprime: 2, 3, 5, 7, 11, 13, 17, ...primary test done by asking does element exists, e.g.13 in prime.fibonacci: 1, 1, 2, 3, 5, 8, 13, 21, ...Compute fibonacci number at any index byfibonacci(i).
It's the same asfibonacci[i], except the list will not growth.Duality Value-Function Data Typepi: 3.1416..., or prime-counting function.phi: 1.6180..., or Euler's totient function.Subscriptable Functionsigma: divisor function,sigma[0]for len andsigma[1]for sum.Number Theoryfactorized: Prime factorization of a number.divisors: Show all positive divisable numbers of a number.Fraction.decimal: Show repeating decimal of a fraction number.Arithmetic Functionproduct: Production of a list of numbers.sumpow: Summation of numbers from[1..n], or[1**p..n**p].sumexp: Summation of numbers from[r**0..r**k].See document in filetest.rstInstallationDownload source and, as rootpython setup.py install
Package: ext-mongo
Depends on environment variables:MONGO_DB(Required)MONGO_HOST(Optional)MONGO_PASSWORD(Optional)MONGO_USER(Default:"root")MONGO_PORT(Optional)Example:fromdatetimeimportdatetime,datefrombsonimportObjectIdfrommongoimportDocument,PrimaryKeyclassDoc(Document):key:int|PrimaryKeya1:str# Requireda2:int|Nonea3:bool|Nonea4:float|Nonea5:ObjectId|Nonea6:datetime|Nonea7:date|Noneb1:list[str]b2:list[int]b3:list[bool]b4:list[float]b5:list[ObjectId]b6:list[datetime]b7:list[date]c1:dictKEY=0A1="a1"d=Doc(key=KEY,a1=A1).save()assertDoc.get(KEY)==dassertDoc.find(a1=A1)==dassertDoc.find_all(a1=A1)==[d]assertd.str_id==str(KEY)assertd.to_dict()=={"_id":KEY,"a1":A1,"b1":[],"b2":[],"b3":[],"b4":[],"b5":[],"b6":[],"b7":[],"c1":{},}
Package: extools
Theextoolspackage provides a number of functions and classes
to make it easier to write clear, concise, Python code in
scripts and modules for Python Extender.extoolsis anopen sourceproject maintained by2665093 Ontario Inc.
Everyone is invited tofile a bug,review the source,
orcontribute.TheAPI documentationis available on readthedocs.io.InstallationTo be available from Extender scripts, theextoolspackage must be
installed in the embedded Extender Python environment.  This is not
trivial.The use of thePython Package Manager for Orchid Extenderis recommended.Included Functions and ClassesFull api documentation for the package is available on readthedocs.io.LicenseTheextoolspackage is distributed under the GNU GPL version 3 copyleft
license.  You must read the license in full before modifying, redistributing,
or using the code in a derivative work.  In short:You may copy, distribute and modify the software as long as you track
changes/dates in source files. Any modifications to or software including
(via compiler) GPL-licensed code must also be made available under the
GPL along with build & install instructions.[1]_[1]fromhttps://tldrlegal.com/license/gnu-general-public-license-v3-(gpl-3)
Package: extoracle
Ext-OracleExt-Oracle Summarization: extractive upper-bound by selecting sentences that maximizes ROUGE-2 score with respect to the target.Installationfrom sources:git clone https://github.com/pltrdy/extoracle_summarization
cd extoracle
pip install .Generating Oracle summary from files(source, target)extoracle source.txt target.txt -method greedy -output oracle.txtParametersextoracle -h 
usage: Ext-Oracle Summarization [-h] [-method {greedy,combination}]
                                [-length LENGTH] [-length_oracle]
                                [-output OUTPUT] [-trunc TRUNC]
                                source target
Ext-Oracle Summarization: error: the following arguments are required: source, targetReferencesPaper: Ext-Oracle is discussed, and measured again summarization datasets inNarayan (2018)Code: this repository uses code fromnlpyang/BertSum(Apache 2.0).
Package: extorch
Extorch: An useful extension library of PyTorch.Extorchis an extension library ofPyTorchthat lets you easily build deep learning systems with PyTorch.📖 DocumentationTutorial: If you are looking for a tutorial, check out examples under./example.Documentation: The API documentation can be found onReadTheDocs.🚀 QuickstartAs the API of this project may alter frequently in its early days, we recommand use the newest version at theGitHubfollowing two steps below.Step 1:git clone https://github.com/A-LinCui/ExtorchStep 2:bash install.shIf you'd like to use the previous stable version.
Simply runpip install extorchin the command line.🎉 Exampleimport extorch.vision.dataset as dataset
    import torch.utils.data as data

    BATCH_SIZE = 128
    NUM_WORKERS = 2

    data_dir = "~/data" # Path to load the dataset
    datasets = dataset.CIFAR10(data_dir) # Construct the CIFAR10 dataset with standard transforms.

    trainloader = data.DataLoader(dataset = datasets.splits()["train"], \
            batch_size = BATCH_SIZE, num_workers = NUM_WORKERS, shuffle = True)
    testloader = data.DataLoader(dataset = datasets.splits()["test"], \
            batch_size = BATCH_SIZE, num_workers = NUM_WORKERS, shuffle = False)More examples can be found in the./examplefolder.👍 ContributionsWe welcome contributions of all kind.
Package: extPep-identifier-blackjack
ExtPep_identifierXinhao Shao @Collage of Pharmacy, University of Illinois at ChicagoPurpose of the scriptExtPep_identifier allows researchers to efficiently identify potential extended peptides given mass-spec search results
and custom database. The extended peptides can be identified after mapping all of the identified peptides to a custom extended
database, followed by a standard non-extended database.Usage1. Package installationInstall the package by running:pip install extPep-identifier-blackjack==0.0.9(or current version)2. Import the packageimport ExtPep_identifier3. Prepare for a few parameters before calling main function# a list of identified peptides strings, ex. ['PEPTIDE','TIDEPEP']peptide_list=your_peptide_getter_function(search_result_file)# a dictionary structure with identified peptide with key, the number of times such peptide being identified as value, ex. {'PEPTIDE':4,'TIDEPEP':5}psm_dictionary = your_psm_getter_function(search_result_file)# a dictionary structure with protein ID as key, it's extended sequence as value, ex. {'P1':'PEPTIDEPEP'}merged_protein_dictionary = your_fasta_reader(custom_ext_database_file_path)# a dictionary structure with protein ID as key, it's original sequence as value, ex. {'P1':'PEPTIDEP'}original_protein_dictionary = your_fasta_reader(original_db_file_path)4. Calling main functionext_pep_list, ext_psm_list, ext_protein_set
= ExtPep_identifier.__main__(peptide_list,psm_dictionary,merged_protein_dictionary,original_protein_dictionary)How to cite:Kyle Mangano, Tanja Florin, Xinhao Shao, Dorota Klepacki, Irina Chelysheva, Zoya Ignatova, Yu Gao, Alexander Mankin,  View ORCID ProfileNora VÃ¡zquez-Laslop
"Genome-wide effects of the antimicrobial peptide apidaecin on translation termination", accepted by eLife
Package: extpickle
Extends the originalPickler classto be able to pickle some otherwise non-supported types.
The emphasis is to be fast and for communication via pipes/sockets
with the same Python version on the other end - thus we don’t care that much for compatibility with other versions.A similar project isdill, which is much bigger though.This project is registeredon PyPIand can be installed viapip install extpickleFor some usage examples, seethe test code.Over the basePicklerclass, it adds pickling support for:types.FunctionType,types.CodeTypeand cell-types.
I.e. you can pickle lamdas and functions.
Note this will use themarshalmodule for the byte-code, so this is not portable across different Python versions.Modules. This is done by referencing it via its name.
Note that is has some extra handling for__main__, which is allowed to be a different module.mod.__dict__wheremodis a module is also stored just as a reference to the module, not a copy of the dict.(Python 2)buffer.numpy.ndarray.
This is also supported by the base class but our implementation is much faster.
Actually this is a bit weird because the default implementation should also be just as fast but it isn’t.
Our implementation basically just usesfromstring/tostring.New-style classes.
The base class would try to look them up in a module. This will fail whenever it cannot be find in such namespace.
Our implementation, if that fails, will actually store the information to construct a new class,
i.e. the name, the bases and its dict.(Python 2) Old-style classes. This is the same behavior as for the new-style classes.This was used in theTaskSystem project.
Package: extprint
extprintprints with color and background colorprints lists and their indexes line by lineInstallpipinstallextprintUsagefromextprintimportprintlist,printcolored,set_default_print_optionslist=[1,2,3,4,5,6,7,8,9,0]printlist(list,seperator="----->",start_index=0,color="GREEN",bold=True)printcolored("HELLO",color="BLUE",bold=True)set_default_print_options(seperator="=",color="VIOLET",bold=True)printlist(list)printcolored("HI")0 -----> 1
1 -----> 2
2 -----> 3
3 -----> 4
4 -----> 5
5 -----> 6
6 -----> 7
7 -----> 8
8 -----> 9
9 -----> 0
HELLO
1 = 1
2 = 2
3 = 3
4 = 4
5 = 5
6 = 6
7 = 7
8 = 8
9 = 9
10 = 0
HIAvailable colors-optionsfromextprintimportshow_available_colorsshow_available_colors()BLACKREDGREENYELLOWBLUEVIOLETBEIGEWHITEBOLDITALIC
Package: extproc
extproc is a layer on top of subprocess. The subprocess module supports
a rich API but is clumsy for many common use cases, namely sync/async
fork-exec, command substitution and pipelining, all of which is trivial
to do on system shells.The goal is to make Python a sane alternative to non-trivial shell scripts.Features:Easy to fork-exec commands, wait or no waitEasy to capture stdout/stderr of children (command substitution)Easy to express I/O redirectionsEasy to construct pipelinesUse short names for easy interactive typingDocumentation is at <http://github.com/aht/extproc/>.This module depends on Python 2.6, or where subprocess is available.
Doctests require /bin/sh to pass. Tested on Linux.This is an alpha release. Expect bugs.
Package: extprot
extprot:  compact, efficient, extensible binary serialization formatThis is a python implementation of the 'extprot' serialization scheme, thedetails of which are described at:http://eigenclass.org/R2/writings/extprot-extensible-protocols-introSimilar to Google's Protocol Buffers and Apache Thrift, extprot allows thedefinition of structured data "messages".  Messages are essentially a setof typed key-value pairs that can be efficiently serialized to/from acompact binary format, and are defined in a language-neutral "protocol" file.Here's a simple example of an extprot message:message person = {id:   int;name: string;emails: [ string ]}Here the 'person' message contains three fields: 'id' is an integer, 'name'is a string, and 'emails' is a list of strings. Such protocol descriptionsare compiled into a set of Python classes that can be manipulated usingstandard syntax and idioms.  If the above protocol is recorded in the file"person.proto", here's a simple example of how it might be used:>>> extprot.import_protocol("person.proto",globals())>>> p1 = person(1,"Guido")>>> print p1.emails   # fields use a sensible default if possible[]>>> p1.emails.append("guido@python.org")>>> p1.emails.append(7)   # all fields are dynamically typecheckedTraceback (mosts recent call last):...ValueError: not a valid String: 7>>> print repr(p1.to_string())'\x01\x1f\x03\x00\x02\x03\x05Guido\x05\x13\x01\x03\x10guido@python.org'>>> print person.from_string(p1.to_string()).name'Guido'>>>Extprot compares favourably to related serialization technologies:* powerful type system;  strongly-typed tuples and lists, tagged disjointunions, parametric polymorphism.* self-delimiting data;  all serialized messages indicate their length,allowing easy streaming and skipping of messages.* self-describing data;  the 'skeleton' of a message can be reconstructedwithout having the protocol definition.* compact binary format; comparable to protocol-buffers/thrift, but withsome overhead due to self-delimiting nature.These features combine to make extprot strongly extensible, often allowingmessages to maintain backward *and* forward compatibility across protocolextensions that include: adding fields to a message, adding elements to atuple, adding cases to a disjoint union, and promoting a primitive type intoa tuple, list or union.The function extprot.import_protocol() will dynamically load a protocol fileand convert it into the corresponding python class structure. This is quiteconvenient while developing a protocol since it avoids an extra compilationstep, but it does add some startup overhead and requires the pyparsing module.To compile a protocol definition into python sourcecode for the correspondingclass definitions, use the function extprot.compile_protocol() or pipe the filethrough extprot/compiler.py like so:$ cat mydefs.proto | python extprot/compiler.py > mydefs.py