Saravanan666/pypi-org huggingface dataset:
Package: conda-env
Provides theconda envinterface to Conda environments.InstallingTo installconda envwith conda, run the following command in your root environment:$condainstall-ccondaconda-envUsageAll of the usage is documented via the--helpflag.$condaenv--helpusage:conda-env[-h]{create,export,list,remove}...positionalarguments:{attach,create,export,list,remove,upload,update}attachEmbedsinformationdescribingyourcondaenvironmentintothenotebookmetadatacreateCreateanenvironmentbasedonanenvironmentfileexportExportagivenenvironmentlistListtheCondaenvironmentsremoveRemoveanenvironmentuploadUploadanenvironmenttoanaconda.orgupdateUpdatesthecurrentenvironmentbasedonenvironmentfileoptionalarguments:-h,--helpshowthishelpmessageandexitenvironment.ymlconda-env allows creating environments using theenvironment.ymlspecification file.  This allows you to specify a name, channels to use when
creating the environment, and the dependencies.  For example, to create an
environment namedstatswith numpy and pandas create anenvironment.ymlfile with this as the contents:name:statsdependencies:-numpy-pandasThen run this from the command line:$condaenvcreateFetchingpackagemetadata:...Solvingpackagespecifications:.Linkingpackages...[COMPLETE]|#################################################| 100%
#
# To activate this environment, use:
# $ source activate numpy
#
# To deactivate this environment, use:
# $ source deactivate
#Your output might vary a little bit depending on whether you have the packages
in your local package cache.You can explicitly provide an environment spec file using-for--fileand the name of the file you would like to use.Envronment file examplename:statschannels:-javascriptdependencies:-python=3.4# or 2.7 if you are feeling nostalgic-bokeh=0.9.2-numpy=1.9.*-nodejs=0.10.*-flask-pip:-Flask-TestingRecommendation:Always create yourenvironment.ymlfile by hand.
Package: conda-envfile
Documentation:https://conda_envfile.readthedocs.ioconda_envfileProvides a Python library, command line tools, and pre-commit tools to manage conda environment files.Command lineconda_envfile_mergeMerge different environment files.
For example:conda_envfile_merge-a"extra-library"env1.ymlenv2.yml>env3.ymlmergesenv1.ymlandenv2.ymland adds the packageextra-libraryto the merged environment fileenv3.yml.conda_envfile_diffShow the difference between two environment files.
For example:conda_envfile_diffenv1.ymlenv2.ymlpre-commitconda_envfile_parseKeep yourenvironment.yamlfile unique, sorted, and legal in terms of version limitations.
In your.pre-commit-config.yaml, add:-repo:https://github.com/tdegeus/conda_envfilerev:v0.5.0hooks:-id:conda_envfile_parsefiles:"environment.yaml"conda_envfile_pyprojectKeep yourpyproject.tomlandenvironment.yamlin sync.
In your.pre-commit-config.yaml, add:-repo:https://github.com/tdegeus/conda_envfilerev:v0.5.0hooks:-id:conda_envfile_pyprojectfiles:"environment.yaml"PythonCombine different version restrictions. For example:importconda_envfilelist(map(str,conda_envfile.unique("foo >1.2.0","foo =1.2.*")))which returns["foo >1.2.0, <1.3.0"]
Package: conda-flow
conda-flowConda flow is a lightweight library that uses both conda and conda-lock to create, curate, and activate locked conda
environments.Why?Managing changes to environment files can be challenging, especially when trying to coordinate with locked environment
details. The lock pattern provides a simple workflow in which:base(or unspecified) env files are edited by developerslocked(or fully specified) env files are produced by conda-lock when running conda-flowThe above workflow has the advantages:Env changes are version-controlledNo lock files are edited directlyIn addition to the locking workflow (which is little more than a wrapper around conda-lock and some file management),
conda-flow also provides an activation workflow. When running the conda-flow activate workflow, the following will
occur:Search for a lock file matching the desired env name (according to config / file structure)Check if an env exists with that name:If yes, then compare checksums of envs to ensure up-to-date with lock file (removing if not)If no, create env from lock fileActivate desired envRun additional configuration scripts as specified in configInstallationAvailable on PyPI:pipinstallconda-flowUsageCreate a directory in your repo for managing base and locked env files (default is<project_root>/.envs). This
directory will be configurable (more docs on config options coming)Create a base env file, with an OS specified according to the filename template (also configurable), for example<project_root>/.envs/base-linux-64.ymlwith a minimal set of packages and specifications for your project. To generate
the locked env<project_root>/.envs/locks/base-linux-64.lock(again name / location configurable), run:conda-flowlock-c/path/to/config-nbase-plinux-64To activate the locked environment, run:conda-flowactivate-c/path/to/config-nbaseThis will:find the proper lock file for the current OS according to the configcheck to make sure any existing defined environments with matching names have matching specifications (checksums)activate the environmentrun any additional configuration scripts specified
Package: conda-hooks
conda-hooksKeep anaconda environment files up to date with installed packages.
In contrast toconda exportit keeps the channel list intact, sorts packages alphabetically and does not purgepipdependencies.conda-hookscan be integrated easily withpre-commithooks to automatically check for any missing packages before committing.InstallationAs a Python packageTheconda_hookspackage is installable as a normal python package, for example via pip:pipinstallconda_hooksAs apre-commithookIn your.pre-commit-config.yamlfile addrepos:-repo:https://github.com/f-koehler/conda-hooksrev:"0.4.2"hooks:-id:conda-env-storeUsageCommand lineRunningenv_store --helpwill print information about the available command line options.
We can either specify paths to environment file explicitlyconda_env_storeenvironment1.ymlenv2.yamlsrc/env3.ymlor use globbing patterns like this:conda_env_store-g**/environment.yml-g**/env.ymlOf course we can combine both methods:conda_env_store-gsrc/env*.ymlenvironment.ymlAs apre-commithookWhen using thepre-commithook we can use the same command line arguments, so please refer to the section above.
An example using globbing patterns would be:repos:-repo:https://github.com/f-koehler/conda-hooksrev:"0.4.1"hooks:-id:prettierargs:["-g","**/environment.yml"]
Package: conda-manager
Descriptionconda-manageris a stand alone Qt application (PySide, PyQt4, PyQt5)
providing a friendly graphical user interface for the management (update,
downgrade, installation and removal) ofcondapackages and environments.Issue trackerChangelogStandalone appSpyder pluginThis project also installs as plugin forspyder(Scientific PYthon
Development EnviRonment) to manage conda packages from within the spyder
application.LicenseThis project is licensed under the MIT license.Installationpip install conda-managerorconda install conda-manager
Package: conda-merge
Tool for merging Conda (Anaconda) environment files into one file.
This is used to merge your application environment file with any other
environment file you might need (e.g. unit-tests, debugging, jupyter notebooks)
and create a consistent environment without breaking dependencies from the
previous environment files.Installation:pip install conda-mergeUsage:conda-merge FILE1 FILE2 ... FILE-N > OUTPUT-FILEA common problem with multiple environment files is that of pinned dependencies:
let’s sayenvironment.ymlcontains the dependencynumpy=1.7, and yourdev-environment.ymlcontainspandasas a dependency. If you sequentially
apply the environment files (conda env update-fenvironment.ymland thenconda env update-fdev-environment.yml)numpywill no longer be pinned
and will be upgraded to the latest version.One option to solve it is by using the pinned dependencies file in the environment
directory, but this means storing your dependencies in another file which interacts
withenvironment.yml, and makes the dependencies less clear to other users.
This script enables you to merge the two environment files and then run only
oneconda envcommand to apply the change.
Package: condansis
CondaNSISCondaNSISpackages Python applications into self-extracting installers forWindowsby leveraging bothconda-packandNSIS.This project is inspired byPyNSIST.Why?Bundlers such asPyInstallerare great for small apps, but often have problems packaging complex projects with many dependencies.
Alternativelly, deployment withCondacan be difficult as as it requires an Anaconda or a Miniconda installation.CondaNSIS solves this problem by packaging your Python app together with alocalandisolatedPython environment, such that the target computer does not need neither Python nor a Conda already installed.InstallationCondaNSIS is avaliable through conda-forgeconda install -c conda-forge condansisUsagePlease see thedocumentation page. Due to limitations of the NSIS dependency,CondaNSIS does not run from Powershell.DevelopersGuilherme Bicalho Saturnino (guisa@orsted.com)
Package: conda-pack
Conda-Packconda-packis a command line tool for creating relocatable conda
environments. This is useful for deploying code in a consistent environment,
potentially in locations where python or conda isn't already installed.See thedocumentationfor more information.Conda-pack is offered under a New BSD license; see thelicense file.Build statusconda install ctools/label/dev::conda-packconda install defaults::conda-packconda install conda-forge::conda-pack
Package: conda-package-handling
conda-package-handlingCreate and extract conda packages of various formats.condaandconda-builduseconda_package_handling.apito create and extract
conda packages. This package also provides thecphcommand line tool to
extract, create, and convert between formats.See alsoconda-package-streaming, an
efficient library to read from new and old format .conda and .tar.bz2 conda
packages.Full documentation athttps://conda.github.io/conda-package-handling/
Package: conda-package-streaming
conda-package-streamingAn efficient library to read from new and old format .conda and .tar.bz2 conda
packages.Download conda metadata from packages without transferring entire file. Get
metadata from local.tar.bz2packages without reading entire files.Uses enhanced piplazy_wheelto fetch a file out of.condawith no more than
3 range requests, but usually 2.Usestar = tarfile.open(fileobj=...)to stream remote.tar.bz2. Closes the
HTTP request once desired files have been seen.QuickstartThe basic API yields (tarfile, member) tuples from conda files as tarfile is
needed to extract member. Note the.tar.bz2format yields all members, not
justinfo/, fromstream_conda_info/stream_conda_component, while the.condaformat yields members from the requested inner archive — allowing the
caller to decide when to stop reading.From a url,fromconda_package_streaming.urlimportstream_conda_info# url = (ends with .conda or .tar.bz2)fortar,memberinstream_conda_info(url):ifmember.name=="info/index.json":index_json=json.load(tar.extractfile(member))breakFrom s3,client=boto3.client("s3")fromconda_package_streaming.s3importstream_conda_info# key = (ends with .conda or .tar.bz2)fortar,memberinstream_conda_info(client,bucket,key):ifmember.name=="info/index.json":index_json=json.load(tar.extractfile(member))breakFrom a filename,fromconda_package_streamingimportpackage_streaming# filename = (ends with .conda or .tar.bz2)fortar,memberinpackage_streaming.stream_conda_info(filename):ifmember.name=="info/index.json":index_json=json.load(tar.extractfile(member))breakFrom a file-like object,fromcontextlibimportclosingfromconda_package_streaming.urlimportconda_reader_for_urlfromconda_package_streaming.package_streamingimportstream_conda_componentfilename,conda=conda_reader_for_url(url)# file object must be seekable for `.conda` format, but merely readable for `.tar.bz2`withclosing(conda):fortar,memberinstream_conda_component(filename,conda,component="info"):ifmember.name=="info/index.json":index_json=json.load(tar.extractfile(member))breakIf you need the entire package, download it first and use the file-based APIs.
The URL-based APIs are more efficient if you only need to access package
metadata.Package goalsExtract conda packages (both formats)Easy to install from pypi or condaDo the least amount of I/O possible (no temporary files, transfer partial packages)Open files from the network / standard HTTP / s3Continue using conda-package-handling to create .conda packagesGenerating documentationUses markdown, furo theme. Requires newer mdit-py-plugins.pip install conda-package-streaming[docs]One time:sphinx-apidoc -o docs .
Package: conda-press
conda-pressPress conda packages into wheels.The wheels created by conda-press are usable in a general Python
setting, i.e. outside of a conda managed environment.Quick startRun theconda presscommand and point it at either an artifact
file or spec. For example:# from artifact spec, produces single wheel, including all non-Python requirements
$ conda press --subdir linux-64 --skip-python --fatten scikit-image=0.15.0=py37hb3f55d8_2

# from artifact file, produces a single wheel
$ conda press numpy-1.14.6-py36he5ce36f_1201.tar.bz2

# from artifact spec, produces wheels for package and all requirements
$ conda press --subdir linux-64 xz=5.2.4=h14c3975_1001

# merge many wheels into a single wheel
$ conda press --merge *.whl --output scikit_image-0.15.0-2_py37hb3f55d8-cp37-cp37m-linux_x86_64.whlWhat we are solvingconda-press allows us to build out a pip-usable package index which is
ABI compatible with conda packages. This can help address the following
issues / workflows:Issue 1:It can be very difficult to build wheels for packages that have C extensions.
Also, the provenance of wheels with C extentions can be hard to know (who built it,
how it was built, etc.). Conda-press enables community building of wheels,
based on conda-forge provided packages. This should make it very easy to build a
valid wheel.Issue 2:Many packages with compiled extensions do not have wheels available on one or more
popular platforms (Windows, Mac, Linux). This is because building wheels can
be very difficult.  Conda has a lot of packages that are not available as wheels otherwise.
Conda-press allows these packages to easily become generally usable wheels.Issue 3:Some people want a package index built on newer ABIs thanmanylinux<N>How to installFrom conda:conda install -c conda-forge conda-pressFrom the source code:$ pip install --no-deps .More technical details about what we are doingWhat conda-press does is take an artifact or spec, and turn it into wheel(s).
When using pip to install such a wheel, it shoves the root level of the artifact
into site-packages. It then provides wrapper / proxy scripts that point to
site-packages/bin so that you may run executables and scripts.How to get involvedPlease feel free to open up a PR or open an issue!
Package: conda-s3-sync
Synchronize Anaconda environments to/from Amazon S3InstallationRunpip installconda-s3-sync, orpython ./setup.pyUsagepositional arguments:
  BUCKET[/PATH]        Bucket and path of S3 location to synchronize to/from

optional arguments:
  -h, --help           show this help message and exit
  --path-filter REGEX  Regular expression of env paths to include
  --conda-bin PATH     Path to conda-binary
  --include-root-env   Include root Anaconda environment in addition to any
                       custom envsAWS credentials should be set up using IAM roles, or the usual environment
variables (such asAWS_ACCESS_KEY_ID,AWS_SECRET_ACCESS_KEYandAWS_DEFAULT_REGION).OperationUpon execution, the list of currently available Anaconda environments in the
local system will be gathered, as will the environments exported to S3.
Any environments that are found missing on either side will be synchronized, by
exporting the local environment and pushing the resulting YAML description to S3, or by creating a new environment from the remote description.Similarly, if environments are present both locally and remotely,
synchronization is performed from the one modified most recently to the one
modified least recently.Local modification time is determined (and persisted) in theenv_path/conda-meta/historyfile modification time.Remote modification time is stored as a custom metadata entry in the S3 objects,
as AWS does not allow setting a customLastModifiedtime.License (MIT)Copyright (C) 2017 Cobli

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 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 THE SOFTWARE.
Package: conda-sphinx-theme
Conda Sphinx ThemeThis is the Conda Sphinx Theme. It extends thePyData Sphinx Themeproject  by adding custom styling.InstallYou can install theconda-sphinx-themevia conda-forge:conda install -c conda-forge conda-sphinx-themeor PyPI:pip install conda-sphinx-themeConfiguringWhen creating a conda subproject you can include this theme by changing this
line in your conf.py filehtml_theme='conda_sphinx_theme'
Package: conda-subprocess
conda subprocessRun a subprocess in a different conda environment.ExampleCreate a new conda environment - in this example a conda environment for Python 3.12:conda create -n py312 python=3.12Open a python shell in your base environment whereconda_subprocessis installed and executepython --versionin thepy312environment:fromconda_subprocessimportcheck_outputcheck_output("python --version",prefix_name="py312")>>>b'Python 3.12.1\n'Alternatively, the environment can be specified with the absolute path:fromconda_subprocessimportcheck_outputcheck_output("python --version",prefix_path="/Users/janssen/mambaforge/envs/py312")>>>b'Python 3.12.1\n'As expected the process for the arguments for the subprocess call can also be defined as list:fromconda_subprocessimportcheck_outputcheck_output(["python","--version"],prefix_path="/Users/janssen/mambaforge/envs/py312")>>>b'Python 3.12.1\n'In addition to thecheck_output()function also thecheck_call()function is implemented:fromconda_subprocessimportcheck_callcheck_call("python --version",prefix_name="py312")>>>Python3.12.1>>>0As well as thecall()function:fromconda_subprocessimportcallcall("python --version",prefix_name="py312")>>>Python3.12.1>>>0And therun()function:fromconda_subprocessimportrunrun("python --version",prefix_name="py312")>>>Python3.12.1>>>CompletedProcess(args=['/bin/bash','/var/folders/9p/rztyv06d0xv4h26cyv8nrw3m0000gq/T/tmpm8b8i0r3'],returncode=0)As theCompletedProcessarguments illustrateconda_subprocessis internally writing the commands to a temporary file
for execution, to guarantee the conda environment is correctly activated.For interactive communicationconda_subprocessimplements thePopeninterface:fromsubprocessimportPIPEfromconda_subprocessimportPopenprocess=Popen(["python","--version"],stdout=PIPE,prefix_name="py312")process.communicate()>>>(b'Python 3.12.1\n',None)RemarksTheshellparameter and theenvparameter are not supported inPopen()and all derived methods.Thepipesizeparameter and theprocess_groupparameter were removed for compatibility with python 3.9.
Package: conda-suggest
conda-suggestSuggest packages to install to obtain command line utilities.QuickstartFirst, install conda-suggest via:$condainstall-cconda-suggestThen you can print a message for which packages to install to obtain a command
via conda-suggest. For example, say we want to know whereg++, the GNU C++
compiler comes from. We would then run something like the following.$condasuggestmessageg++
Command'g++'notfoundintheenvironment,butcanbeinstalledwithanyof:$condainstall-cconda-forgecxx-compilerThe above assumes that the map files for theconda-forgechannel have also been installed.Python APIYou may also use conda-suggest programatically. For example:fromconda_suggest.findimportmessage,exact_find,substring_findmessage("g++")exact_find("python")substring_find("xonsh")Map filesConda-suggest works by looking for "map files" on the system. Map files are simple
text files where every line associates a command name with a package name separated
by a colon, i.e.<command>:<package>\n. For example:zfp:zfp
zic:tzcode
zima:pint-pulsar
zip:zip
zipcmp:libzipThese map files must be lexicographically sorted, first by the command, and then by the package.
The map files are named according to the following scheme:<channel-name>.<subdir>.map.
Themessagecommand (and others) will load and search all map files on$CONDA_SUGGEST_PATH.
This environment variable will default to"~/.local/share/conda-suggest:<sys.exec_prefix>/share/conda-suggest"or it's platform-specific
equivalent.Users should install map files for all channels that they frequently use.Generating the Map Files & the Cache FilesCreating the map files can be a tedious job because it requires searching through all artifacts on
a channel. Theconda suggest generatecommand automates this process for you. Currently this can
look through a channel's artifacts in a local directory:$condasuggestgenerate/path/to/mirrors/channel-nameTo make restarts safe and fast, the above command produces "cache files" with the naming
scheme<channel-name>.<subdir>.cache.json. These are JSON files with the following layout:{"<artifact-filename>":{"executables":["cmd0","cmd1",...],"package":"<package-name>"},...}In the cache file, the artifact name is the same as the artifact filename in therepodata.jsonfor that channel & subdir combo. The package name is taken from the
equivalent repodata entry.Generating these cache files can take a very long time and they tend to be quite large.
It is not recommended that you distribute these caches as part of any package. They are
intended for local use only. The map files are the intended distibutable result.At some point in the future, we would like to be able to generate maps based off of a
remoterepodata.jsonas well.
Package: condat-gridconv
Hexagonal-cartesian grid conversionThis is an implementation of (part of) the algorithm described in
Condat et al.Reversible, fast, and high-quality grid conversions,
IEEE Transactions on Image Processing, vol. 17, no. 5, pp. 679-693, May 2008.
It transforms data sampled on a hexagonal grid, such as an X-ray detector with
hexagonal pixels, into a conventional cartesian lattice.Specifically, it implements what that paper describes as a Type II fractional
delay filter, with N=2.This package is based on code written by Andreas Scherz and Rafael Gort.