Saravanan666/pypi-org huggingface dataset:
Package: compoundfiles
This package provides a library for reading Microsoft’sCompound File Binaryformat (CFB), formerly known asOLE Compound Documents, theAdvanced
Authoring Format(AAF), or just plain old Microsoft Office files (the non-XML
sort). This format is also widely used with certain media systems and a number
of scientific applications (tomography and microscopy).The code is pure Python and should run on any platform; it is compatible with
Python 2.7 (or above) and Python 3.2 (or above). The library has an emphasis
on rigour and performs numerous validity checks on opened files.  By default,
the library merely warns when it comes across non-fatal errors in source files
but this behaviour is configurable by developers through Python’swarningsmechanisms.LinksThe code is licensed under theMIT licenseThesource codecan be obtained from GitHub, which also hosts thebug
trackerThedocumentation(which includes installation instructions and
quick-start examples) can be read on ReadTheDocsThebuild statuscan be observed on Travis CI
Package: compoundinterest
COMPOUND INTEREST FACTORSThis is a module of compound interest factors which includes single payment, uniform payment series, and arithmetic gradient calculationsBy ZaafirrahmanInstallationThis library can be installed by the pip command, open your terminal and type in the following command...pipinstallcompoundinterestFunctions of this libraryFirst import the library using this commandimportcompoundinterestasciand then proceed to call the functionsSingle Paymentci.fp()This function can be used to calculate compound interest factor of future value based on present valueci.pf()This function can be used to calculate compound interest factor of present value based on future valueUniform Payment Seriesci.fa()This function can be used to calculate compound interest factor of future value based on annual valueci.af()This function can be used to calculate compound interest factor of annual value based on future valueci.pa()This function can be used to calculate compound interest factor of present value based on annual valueci.ap()This function can be used to calculate compound interest factor of annual value based on present valueArithmetic Gradientci.pg()This function can be used to calculate compound interest factor of present value based on gradient valueci.ag()This function can be used to calculate compound interest factor of annual value based on gradient valueThe parametersi (interest rate)- Interest rate (without percent) used in the calculationn (time period)- Investment time period (in year/s) used in the calculationExample :You are saving $ 30,000 USD in the bank at an interest rate of 10% annually. How much will it be worth when you take it in 5 years?In this case, the variables that you already know are present value ($ 30,000 USD), interest rate (10%), and investment period (5 years). Whereas the variable that you are looking for is the future value. So you will need theci.fp()function with the following calculations:>>>importcompoundinterestasci>>>ci.fp(10,5)*3000048315.30000000002So, your money in the next 5 years is $ 48,315.3 USD
Package: compound-jsonapi
The Compound JSONAPI package is an extension toMarshmallowand has been
heavily influenced byMarshmallow JSONAPI. The difference toMarshmallow JSONAPIis that the Compound JSONAPI is focused on loading
and dumping objects to compound JSONAPI documents that contain all the
serialised data, rather than using JSONAPI’s link functionality. It has one
main advantage overMarshmallow JSONAPIin that it can load and dump full
circular graph structures.Sourcecode can be found here:https://bitbucket.org/mhall/compound-jsonapi/Documentation can be found here:http://compound-jsonapi.readthedocs.io/1.0.1BUGFIX: Fix issues introduced by the load/dump API change in Marshmallow1.0.0Initial version
Package: compoundpi
This project provides a means for controlling multiplecamerasattached toRaspberry Pisall of which are attached to the same subnet. Broadcast UDP
packets are utilized to permit near-simultaneous triggering of all attached
cameras.LinksThe code is licensed under theGPL v2or aboveThesource codecan be obtained from GitHub, which also hosts thebug trackerThedocumentation(which includes installation and quick start examples)
can be read on ReadTheDocsPackages can bedownloadedfrom PyPI, although reading the installation
instructions will probably be more useful
Package: compoundwidgets
CompoundWidgetsCustom widgets based on tkinter/ttk/ttkbootstrap libraries.To be used in conjunction with tkinter, tkinter.ttk and ttkbootstrap.Intends to help create widgets on the following formats:. label + combobox. label + combobox + button. label + entry. label + entry + button. label + entry + combobox (for engineering applications). label + spinbox (including float spinbox). label + text. label + spinboxCreates a set of buttons with icons for regular methods, such as 'cancel', 'clear', 'help',
'no', 'yes', 'quit', 'save', and so on.Also creates new style of buttons ("led" like buttons). The following are available:. CheckLedButton. LedButton. RadioLedButtonHas three frames with additional properties:. Collapsable frame. Scrollable frame. Vertical Collapsable frameIncludes toplevel widgets:. ok/cancel message box. yes/no message box. progress bar message box. success message box. warning message box. tooltip message box. timed message boxIncludes the entry validation required methods for "numbers only" and for maximum number of characters.Includes autocomplete widgets, such as:. Autocomplete Combobox. Autocomplete EntryList. Autocomplete LabelCombo
Package: compoz
CompozCompoz is a lightweight composition package.OverviewCompoz provides with two main functions:composite (for standard composition)pipe (for reversed composition)'composite''composite' will run from last to the first function provided.fromcompozimportcompositedefmultiply_by_3(n:int)->int:returnn*3defsubtract_5(n:int)->int:returnn-5composite_func_1=composite(subtract_5,multiply_by_3)print(composite_func_1(10))# Output will be 25composite_func_2=composite(multiply_by_3,subtract_5)print(composite_func_2(10))# Output will be 15'pipe''pipe' will run from first to the last function provided.fromcompozimportpipedefmultiply_by_3(n:int)->int:returnn*3defsubtract_5(n:int)->int:returnn-5pipe_func_1=pipe(subtract_5,multiply_by_3)print(pipe_func_1(10))# Output will be 15pipe_func_2=pipe(multiply_by_3,subtract_5)print(pipe_func_2(10))# Output will be 25
Package: compoze
compoze READMEThis package provides a script for creatingsetuptools-compatible
package indexes using packages downloaded from other indexes.Please seedocs/index.rstfor the documentation, which can also be
read online at:http://docs.repoze.org/compozehttp://packages.python.org/compozecompoze Changelog1.0 (2012-02-10)Addedsetup.py docsalias (installs ‘Sphinx’ after runningsetup.py develop).Updated Trove classifiers.1.0b1 (2012-12-28)Added support for building docs undertox, including testing any
doctest snippets.Added support for Python 3.2 and 3.3, including testing them undertox.Added support for PyPy, including testing it undertox.Added coverage testing for undertox.Added testing for supported Python versions undertox.Added logic to handle archives (e.g., Twisted’s) which contain multiple
‘setup.py’ files.  Thanks to Travis Jensen for the patch.Addedsetup.py devalias (installs ‘nose’ and ‘coverage’ after runningsetup.py develop).compoze 0.4.1.1 (2012-04-19)Repair packaging error in 0.4.1 (CHANGES.txt not included in the tarball).compoze 0.4.1 (2012-03-18)Harden ‘compoze.indexer’ against archives containing ‘setup.py’ which
exit with errors, or which return bad data for ‘setup.py –name –version’.
Fixeshttp://bugs.repoze.org/issue69:  thanks to Paul Winkler for the
original version of the patch.compoze 0.4 (2010-03-29)Added global--use-versionsand--versions-sectionoptions, to
permit specifying requirements from the configuration file.  Updatedcompoze fetchandcompoze showto use such requirements.Normalized options, allowing more to be set globally or in the config
file:--index-url,--find-links,--fetch-site-packages,--include-binary-eggs,--keep-tempdir.Updated spelling of--find-linkoption to--find-links.Added a global--config-fileoption to permit setting options in an
INI-style config file.compoze 0.3.1 (2010-03-25)Fix bug incompoze fetchunder recent setuptools:
“AttributeError: NoneType has no attribute ‘clone’”.Fix bug incompoze showunder recent setuptools:
“AttributeError: EmptyProvider instance has no attribute ‘name’”.Further documentation improvements.compoze 0.3 (2010-03-25)Added Sphinx documentation.Switched to usingpkginfoto parse package information.Addedpoolcommand which moves all archives in the current directory
to a common pool directory and symlinks them back.Addedshowcommand, which displays locations for one or more
requirements across a set of indexes.compoze 0.2 (2007-11-19)Added--help-commandsoption to show subcommands.Brokefetchandindexout as subcommands;  other commands can
be registered using the pkg_resources entry point group,compoze_commands.compoze 0.1 (2007-11-14)Initial release.
Package: compphysutils
CompPhysUtilsCollection of Python utilities for Computational Condensed Matter PhysicistsCompPhysUtils is a library of utilities that automate and simplify certain mundane tasks so that you
can spend more time investigating physical phenomena and less time generating coordinates of various
clusters, deciding on details of plots etc.The development is in early stages and is based on collection of code generated during the author's
PhD study. More code will be present in the future, as well as documentation.CompPhysUtils aims to be highly configurable and highly extensible. As a library, it is distributed
under the LGPL v3 license, so that you can use it pretty much without restriction, but if you decide
to change its functionality or extended the code itself significantly, you are required to share it
with the community.
Package: compreq
compreqA library for dynamically computing Python requirements, to keep them up-to-date.ConceptsThis library relies heavily onpackaging, and you should
understand that first.The base types are theVersion,Specifier,SpecifierSetandRequirementinpackagingandReleaseandReleaseSetadded by this library.For all of the base types this library adds lazy versions - which both allows reuse, but also allows
some values to be fetched from the context, instead of specified explicitly.To resolve a lazy object into a concrete value use aCompReq.resolve_...method.Finally this library adds wrappers aroundpyproject.tomlandrequirements.txtfiles, for getting
and setting the requirments in them.Example:importcompreqascrwithcr.PoetryPyprojectFile.open()aspyproject:prev_python_specifier=cr.get_bounds(pyproject.get_requirements()["python"].specifier).lower_specifier_set()comp_req=cr.CompReq(python_specifier=prev_python_specifier)default_range=cr.version(">=",cr.floor_ver(cr.REL_MINOR,cr.minimum_ver(cr.max_ver(cr.min_age(years=1)),cr.min_ver(cr.count(cr.MINOR,3)),),),)&cr.version("<",cr.ceil_ver(cr.REL_MAJOR,cr.max_ver()))dev_range=cr.version(">=",cr.floor_ver(cr.REL_MINOR,cr.max_ver()))&cr.version("<",cr.ceil_ver(cr.REL_MINOR,cr.max_ver()))pyproject.set_requirements(comp_req,[cr.pkg("beautifulsoup4")&default_range,cr.pkg("packaging")&default_range,cr.pkg("pip")&default_range,cr.pkg("python")&default_range,cr.pkg("python-dateutil")&default_range,cr.pkg("requests")&default_range,cr.pkg("tomlkit")&default_range,cr.pkg("typing-extensions")&default_range,],)pyproject.set_requirements(comp_req,[cr.pkg("black")&dev_range,cr.pkg("isort")&dev_range,cr.pkg("mypy")&dev_range,cr.pkg("pylint")&dev_range,cr.pkg("pytest")&dev_range,cr.pkg("taskipy")&dev_range,cr.pkg("types-beautifulsoup4")&default_range,cr.pkg("types-python-dateutil")&default_range,cr.pkg("types-requests")&default_range,],"dev",)Or seerequirements.py.References:https://peps.python.org/pep-0440/https://packaging.pypa.io/en/stable
Package: compress
Welcome tocompressDocumentationThere’s lots of mature data compression algorithm you can choose from,compressprovidesnormalized APIto use them andswitch between them.It supports:From Python Standard library:zlib.bz2.lzma, high compression ratio but slowFrom Community (Additional Library Required):snappy, from Google, lower compression ratio but super fast! (on MacOS, you need to install it viabrew install snappy, on Ubuntu, you needsudoapt-getinstalllibsnappy-dev.lz4, lower ratio, super fast!Notesome package are not installed along withcompress. Becauseall of them needs C compiler, you have to manually install them. If you have trouble installing C compiler for your OS, readTHIS TUTORIAL.Usage:>>> from compress import Compressor
>>> binary_data = ("hello world! " * 100).encode("utf-8")
>>> c = Compressor()
>>> c.use_gzip() # or use_bz2, use_lzma, use_lz4, use_snappy
>>> c.compress(binary_data, zlib_level=9)
>>> c.decompress(binary_data)Other API for lazy developer:>>> import compress
>>> compress.compress_bytes_to_bytes
>>> compress.compress_str_to_bytes
>>> compress.compress_bytes_to_b64str # compress, and returns b64 encoded str
>>> compress.compress_str_to_b64str # compress string and returns b64 encoded str

>>> compress.decompress_bytes_to_bytes # inverse of compress_bytes_to_bytes
>>> compress.decompress_bytes_to_str # inverse of compress_str_to_bytes
>>> compress.decompress_b64str_to_bytes # inverse of compress_bytes_to_b64str
>>> compress.decompress_b64str_to_str # inverse of compress_str_to_b64str

    compress_bytes_to_bytes, compress_str_to_bytes,
compress_bytes_to_b64str, compress_str_to_b64str,
decompress_bytes_to_bytes, decompress_bytes_to_str,
decompress_b64str_to_bytes, decompress_b64str_to_str,This websiteprovides comprehensive comparison and visualization. But how do you knowhow it works on your own production environment?.compresscomes with a tool to run benchmark test forAll test case, All algorithm, All parameters, and you will get informative stats about ratio, compress/decompress speed in.tabandascii tableformat. Then You are able to visualize it in the way you preferred.To run benchmark test, just:$ pip install -r requirements-benchmark.txt
$ python ./benchmark/run.pyInstallcompressis released on PyPI, so all you need is:$pipinstallcompressTo upgrade to latest version:$pipinstall--upgradecompress
Package: compressbinarytable
CompressBinaryTableBasic Usage:cbt -i input_file -o output_file -cOptions:-i = input, required-o = output, required-c = compression-d = decompression-t = output type, either csv or tsv--override = to override output file if it existAvailable Python functions:# Returns numpy array of file as uncompressed, useful for ML (same as load as pandas df, and to_numpy())
cbt_to_array(compressed_file)

# Returns numpy array of name of the mutations as uncompressed, useful for ML, (same as load pandas df and use df.colums)
cbt_columns(compressed_file)Required file example:CSV:strain_name,mut1,mut2,mut3,mut4,outcome
strain1,0,1,1,1,1,1
strain2,0,0,1,1,1,0
strain3,0,1,0,1,1,0
strain4,1,1,1,1,1,1TSV:strain_name mut1    mut2    mut3    mut4    outcome
strain1 0   1   1   1   1   1
strain2 0   0   1   1   1   0
strain3 0   1   0   1   1   0
strain4 1   1   1   1   1   1CBT:1;mut1;mut2;mut3;mut4;outcome
strain1;6;43;87;102
strain2;16;43;87;102
strain3;6;53;78;112
strain4;61;413;824;942
Package: compress-comics
compress_comicsFind all the cbz/cbr files in the current directory and subdirectories and compress all the jpg/png/gif images inside with jpeg xl.Output files preserve the folder structure.Repacks cbr into cbz.By default, compresses with:-d / --distance 0 (lossless)
-j / --lossless_jpeg 1Compresses as many images in parallel as there are threads.Because of that, it may run out of memory on bigger resolutions.Adjust with:-t / --threadsBasic usage:compress_comics -O output_directoryTo check all program options:compress_comics -hNeedscjxlinstalled and in PATH.
Package: compress-comics-TheHardew
compress_comicsFind all the cbz/cbr files in the current directory and subdirectories and compress all the jpg/png/gif images inside with jpeg xl.Output files preserve the folder structure.Repacks cbr into cbz.By default, compresses with:-d / --distance 0 (lossless)
-j / --lossless_jpeg 1Compresses as many images in parallel as there are threads.Because of that, it may run out of memory on bigger resolutions.Adjust with:-t / --threadsBasic usage:compress_comics output_directoryTo check all program options:compress_comics -hNeedscjxlinstalled and in PATH.
Package: compressed-deque
Copyright (c) 2016, Pedro LopesPermission is hereby granted, free of charge, to any person obtaining a copyof this software and associated documentation files (the "Software"), to dealin the Software without restriction, including without limitation the rightsto use, copy, modify, merge, publish, distribute, sublicense, and/or sellcopies of the Software, and to permit persons to whom the Software isfurnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in allcopies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ORIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THEAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHERLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THESOFTWARE.Description: Compressed Deque================A deque which compresses its items for a decreased volatile and persistent memory footprint.Installation------------.. code-block:: bash$ pip install compressed-dequeHow to Use it-------------.. code-block:: pythonfrom compdeque import CompressedDeque# Instantiate the Dequecollection = CompressedDeque()# Use it as a normal dequecollection.append(1)# Persist to a fileCompressedDeque.save_to_file(collection, file_path="/path/to/collection.dat")# ...# and load it when you need it laterloaded_collection = CompressedDeque.load_from_file("/path/to/collection.dat")Tests and documentation-----------------------On the project's root folder:.. code-block:: bash# Run all tests$ make test# Generate documentation$ make docsStructure---------Compressed Deque inherits from `deque <https://docs.python.org/2/library/collections.html#collections.deque>`_ and stores its items as zlib compressed pickles. The middle pickle layer only serves as a generic serialization method which can provide a serialized object string for zlib to compress. Although pickle can compress objects, its compression rate does not match zlib's, even using `higher protocols <https://docs.python.org/2/library/pickle.html#data-stream-format>`_... image:: docs/images/value_layers.png``save_to_file()`` and ``load_from_file()`` static methods are provided to persist the collection directly into disk in its compressed representation, without much overhead.The persisted file contains a sequence of header/compressed_value pairs: the header is a 4 byte integer description of the compressed value's length and the compressed value is similiar to its in-memory representation... image:: docs/images/persisted_values.pngKeywords: compressed deque zipped zlibPlatform: UNKNOWNClassifier: Development Status :: 3 - AlphaClassifier: Intended Audience :: DevelopersClassifier: Topic :: Software Development :: Build ToolsClassifier: License :: OSI Approved :: MIT LicenseClassifier: Programming Language :: Python :: 2Classifier: Programming Language :: Python :: 2.6Classifier: Programming Language :: Python :: 2.7
Package: compressed-file-iterator
compressed_file_iteratorConfigurable iterator-based access to compressed files.This is a simple package to provide configurable iterator-based access to compressed files.Usage:foo.json{
    ".gz": {
        "base_command": {
            "posix": "/bin/gzip"
        },
        "base_options": {
            "posix": [ '-d', '-c', ]
        },
        "type": "Gzip"
    },
    ".*": {
        "base_command": {
            "posix": "/bin/cat"
        },
        "base_options": {
            "posix": []
        },
        "type": "Plain"
    }
}importcompressed_file_iterator# ...my_iterator=compressed_file_iterator.MyIterator('foo.txt',config_file='foo.json',case_sensitive=True,)forlineinmy_iterator:print(line)# ...InstallationTODO: (Upload to allow for install via pip.)$ pip install compressed_file_iteratorDocumentationClass definitionclasscompressed_file_iterator():def__init__(self,args,cwd='./',config_file='compressed_file_iterator.json',case_sensitive=True,):Parametersargs : listContains file name to open.cwd : string, optionalWorking directory. (Default: '.').config_file : string, optionalJSON configuration defining extensions and how to handle them.case_sensitive : boolean, optionalPerform match attempts against JSON configuration in a
case-sensitive manner. If False, process via string.casefold()
before testing. (Default: True)JSON Format{
        '.extension': {
                'base_command': {
                    os_name: path_to_executable,
                },
                'base_options': {
                        os_name: [ command_line_options ],
                'type': string
        },
}Parameters.extension: stringA string representation of a file extension, as separated by pathlib.Path().suffixes.A default definition should be included for '.*' to be used if
no other match can be made.base_command: dictionaryContains one or more commands, indexed by the value of os.name on the system.base_options: dictionaryContains one or more lists consisting of zero or more options
required by the appropriate base_command to output content on STDOUT.
Indexed by the value of os.name.type: stringString identifier for the compression configuration. (Currently unused.)AcknowledgementsTo my friend, Chris Jones, for suggesting I add the option of case-insensitive extension matching.To the members of #python on the Libera.Chat IRC network, for patiently enduring my numerous questions.