Saravanan666/pypi-org huggingface dataset:
Package: pkgcore
pkgcorepkgcore is a framework for package management; via the appropriate class
plugins, the design should allow for any underlying repository/config/format to
be used; slackware’s tgzs being exempted due to lack of any real metadata, and
autopackage format being exempted due to the fact they effectively embed the
manager in each package (pkgcoredoesrequire being able to treat the pkg as
data, instead of autopackage’s method of handing resolution/all manager ops off
to the package script).Toolspclean: clean distfiles, binpkgs, and builds dirspclonecache: clone a repository cachepconfig: query configuration infopebuild: low-level ebuild operations, go through phases manuallypinspect: inspect repository related infopmaint: repository maintenance (syncing, copying…)pmerge: dependency resolution, fetching, (un)merging, etc.pquery: query repository info, revdeps, pkg search, vdb search, etc.RequirementsAt least python version 3.10, andsnakeoil— a utility library split out of
pkgcore for others to use.InstallingInstalling latest pypi release:pip install pkgcoreInstalling from git:pip install https://github.com/pkgcore/pkgcore/archive/master.tar.gzInstalling from a tarball:python setup.py installTestsStandard python test runners can be used, for example:pytest -vA tox config is provided so the testsuite can be run in a
virtualenv setup against all supported python versions. To run tests for all
environments just executetoxin the root directory of a repo or unpacked
tarball. Otherwise, for a specific python version execute something similar to
the following:tox -e py39DocsDocumentation is available onGithub.ContactFor bugs and feature requests please create anissue.
Package: pkgcraft
pkgcraft-pythonPython bindings forpkgcraft.InstallInstall wheel from PyPI (comes with bundledpkgcraft-clibrary):pip install pkgcraftInstall from git (assumespkgcraft-cfrom git is installed):git clone --recurse-submodules https://github.com/pkgcraft/pkgcraft-python.git
pip install pkgcraft-pythonDevelopmentRequirements:toxandpkgcraft-cFor development purposes, testing is performed under tox with varying targets
for different functions, e.g.tox-evalgrindruns tests while checking for
memory leaks usingvalgrind. Usetox listto see all the target
descriptions.
Package: pkgdependency
ContentsRequirementsInstallationExampleCopyrightValidates package requirementsRequirementsPython:termcolor == 1.1.0InstallationThe last stable release is available on PyPI and can be installed withpip$ pip install pkgdependencyExampleUsing Functionfrom pkgdependency import verify_dependency
verify_dependency(path/to/requirements)Using Command$ pkgdep path/to/requirementsExample of a case in which the requirements are not met>>> VERSION CONFLICT: examplepkg(1.0.0) => (2.0)
>>> NOT FOUND: examplepkg(any)Create requirement text$ my_project $ tree requirements/
/requirements/
├── base.txt
├── local.txt
└── server.txtCreate base requirement$ pip freeze > base.txtCreate environment requirement-r base.txt
pytest==2.7.0CopyrightCopyright - Copyright (C) 2016 gumi Inc.
Package: pkgdeps
Explore dependencies of a Python package by parsing its imports.This might be useful for:seeing how modules within a package depend on each otherseeing which built-in libraries are relied uponanalysis of 3rd-party dependenciesetc.ExamplesExplore dependencies of this project:$ pkgdeps /path/to/pkgdeps
pkgdeps
  - argparse.ArgumentParser
  - ast
  - collections.defaultdict
  - functools.reduce
  - os
  - os.path
  - sysLimitationsOnly tested with Python 3 against Python 3 packages.Doesn’t handle conditional imports; all conditional branches are inspected.Outputs imported module members:from os.path import joincreates a
dependency onos.path.join, but we probably only wantos.pathfor e.g.tsortoutput. However, internal dependencies are coarsened to the module
level.Installation$ pip install pkgdepsUsageVarious options are available to filter and format the output:$ pkgdeps -h
usage: pkgdeps [-h] [-n <num>] [-m <num>] [-e <type> | -o <type>]
               [-f <format>]
               </path/to/package>

Explore dependencies of a package by parsing its imports.

positional arguments:
  </path/to/package>    path to package root

optional arguments:
  -h, --help            show this help message and exit
  -n <num>, --package-module-name-segments <num>
                        truncate module names of inspected package to given
                        number of segments (and consolidate imports)
  -m <num>, --dependency-module-name-segments <num>
                        truncate module names of dependencies to given number
                        of segments (and deduplicate)
  -e <type>, --exclude <type>
                        exclude various kinds of dependencies from output
                        (builtin, 3rd-party, internal)
  -o <type>, --only <type>
                        include only dependencies of the given type (builtin,
                        3rd-party, internal)
  -f <format>, --format <format>
                        graph output format (tree, tsort)
Package: pkg-deps
# Print dependency info in graph formpkg-depsis a tool to examine dependency information about installed Python
packages, and render it in a variety of ways.  Various checks can also be run.
As of version 1.0, the output formats include:human-readable text output with highlighting of problems,teamcity, for specially-formatted messages that the TeamCity CI tool can
understand (to use this, usepip install pkg-deps[teamcity]),dot, for rendering with GraphViz, andJSON, for further processing with automated tools (including re-loading
and combining dependency graphs by this tool!)The checks it can run include (again, as of 1.0):finding dependency loops,finding unmet dependencies, including unmet version requirements,finding outdated packages,ensuring that certain packages specify exact (‘==’) version dependencies,
andensuring that certain packages do not have any indirect dependencies - e.g.
making sure a web app pinsallof its dependencies, including otherwise
indirect ones.The tool has several dependencies itself, so to avoid having to install it in
each virtualenv you want to examine, it also supports running a probe with
a different Python binary.  For example, you could install it once usingpipsiand then run it in your current virtualenv withpkg-deps -p `which
python`.For details on how to accomplish these things, runpkg-deps –help.
Package: pkgdev
pkgdevpkgdev provides a collection of tools for Gentoo development including:pkgdev commit: commit to an ebuild repositorypkgdev manifest: update package manifestspkgdev mask: mask packagespkgdev push: scan commits for QA issues before pushing upstreampkgdev showkw: show package keywordsDependenciespkgdev is developed alongsidepkgcheck,pkgcore, andsnakeoil. Running
pkgdev from git will often require them from git as well.For releases, see the required runtimedependencies.InstallingInstalling latest pypi release:pip install pkgdevInstalling from git:pip install https://github.com/pkgcore/pkgdev/archive/main.tar.gzInstalling from a tarball:pip install .
Package: pkgdiff
Compare FreeBSD pkg files by metadatapkgdiffis a plugin for the FreeBSD package managerpkgas well as a Python
extension for comparing package files by their metadata.To that end it uses libpkg (distributed along with thepkgcommandline tools), to open and parse package files and either a basic
string compare or a line-by-line diff algorithm to complare the
metadata fields.How to installThe Python extension is easily installed by running:pipinstallpkgdiffBasic usageimportpkgdiffifpkgdiff.compare('pkg-1.14.5.txz','pkg-1.14.6.txz',exclude=['version']):print('packages are equal (ignoring version)')
Package: pkg-downloader
pkg-downloaderA package downloader for Ubuntu, Debian, and CentOS that downloads the .deb or .rpm packages and their dependencies.Installation & RequirementsPrerequisitesPython 3.7.2+DockerInstall pkg-downloaderpip3 install pkg-downloaderExaple UsageTo download packages for centos 8:pkg-downloader --os centos --version 8 --packages nginx postgresqlTo download packages for ubuntu 20.04 to a specific directory:pkg-downloader --os ubuntu --version 20.04 --location ~/Desktop --packages nginx postgresql
Package: pkg_dvp_mathematique
Ceci est le contenu du fichier README.TXT. Il s’agit d’un fichier texte ou RST contenant la description longue du paquet. Déporté cette description dans un fichier externe à setup.py permet d’améliorer la lisibilité du code de setup.py.
Ce fichier contient normalement au minimum le nom du paquet, son but, la licence et un hyperlien si possible. Il peut etre utile d’ajouter en sus un exemple.L’article lié à ce paquet est disponible ici:http://deusyss.developpez.com/tutoriels/Python/packaging_pypi/
Package: pkgen
IntroductionPkGenis a pk generator implemented using Python, who’s core algorithm
derives fromMongo’sgeneration ofObjectId.Basic Concept of ObjectIdA BSON ObjectId is a 12-byte value consisting of a 4-byte timestamp
(seconds since epoch), a 3-byte machine id, a 2-byte process id(PID)
and a 3-byte counter. Note tha the timestamp and counter fields must
be stored big endian unlike the rest of BSON.MoreInstall2 ways to installPkGen:clone the repo to your machine, runsetup.py$cd~&&git@github.com:streethacker/pkgen.git$pythonsetup.pyinstallusing pip$pipinstall-egit+https://github.com/streethacker/pkgen@0.1#egg=pkgenStart>>>frompkgenimportPkGen>>>pkg=PkGen()>>>pk=pkg.pkgen()>>>pk.pk'5735ae95c14e2435aa000000'>>>
Package: pkgexample
pkgexampleLast updated 28th August 2022Welcome to the readme for this simple package.
More informationClick HereIntroductionThis is a README file for the RexBytes simple example.
It's created using Github-flavoured Markdown, you can
create a README for your project, for more informationClick HereBuild InstructionsA full detailed instruction on python package buildingis available hereYou should read it in full to understand the following overview of the process.Here we use the "setuptools" build system, others are availble ("Hatching","Flit", and "PDM") in the guide linked above.In short, these are the steps.(1/4) Create the following files in your project root directory,README.mdLICENCEpyproject.toml(2/4) Build a PyPi release.From the root of your project directory, run the following command,python3 -m buildThis command will create a ./dist/ directory containing your distribution files.(3/4) Check your distribution files.You should really check your distribution files for errors before submitting them to pypi.org
Run the following command from the root of you project directory to do so.python3 -m twine check ./dist/*(4/4) Upload your fresh package to pypiIf your packages passed the checks you can upload them to your pypi.org repository.
Run the following command from the root of your project directory to do so.python3 -m twine upload ./dist/*You will be asked for your pypi user name and password.Enjoy!Have fun packaging python!
Package: pkgexampleconsole
pkgexampleconsoleWelcome to the readme for this console package example.
More informationClick HereIntroductionThis is a README file for the RexBytes simple console example.
It's created using Github-flavoured Markdown, you can
create a README for your project, for more informationClick HereThis console package example demostrates how to run your
python code as a console command.Further Readinghttps://rexbytes.com/2022/09/01/python-packages-as-callable-console-scripts/
Package: pkgexampledatabases
pkgexampledatabasesA RexBytes example package that shows you how to,Create and address an sqlite3 database inside your python package.Create and address an sqlite3 database at anyother location on a filesystem.
Access to a users home directory is used as the example.The following config files are used to describe two sqlite databases./pkgexampledatabases/data/config/packagedb.json
This is the json description file for the database that is constructed inside your package./pkgexampledatabases/data/config/userdb.json
This is the json desctiption file for the database that is constructed inside a users home directory.You can have as many database entries in the above files as you like.
It is convenient to describe your databases in json format and let your package create the
end user databases.
Package: pkg-FormulaBasedMaterials
FormulaBasedMaterialsGenerate Formula-Based Materials into Voxel, STL filesUsage:importmatplotlib.pyplotasplt%matplotlibinlineimportFormulaBasedMaterialsasFBMtest_SingleFM=FBM.SingleFormulaBasedMaterials(formula='sin(x)*cos(y)+sin(y)*cos(z)+sin(z)*cos(x)+1',l=10,r=[1,1,1],a=[1,1,1],eps=0.2,res=0.2,png=True,smooth=True)test_SingleFM=FBM.SingleFormulaBasedMaterials(unit='random')test_SingleFM=FBM.SingleFormulaBasedMaterials(unit='SchD')test_SingleFM=FBM.SingleFormulaBasedMaterials(unit='gyroid')test_SingleFM.save2stl()
Package: pkg-info
Tiny library to fetch package info fromPyPI.Installpipenv install pkg_infoorpip install pkg_infoUsagefrompkg_infoimportget_pkg_infopkg=get_pkg_info('requests')pkg.name# 'requests'pkg.version# '2.18.4'pkg.author.name# 'Kenneth Reitz'List of supported propertiesname:strlicense:strsummary:strdescription:strversion:strkeywords:strhomepage:strurl:strauthor:-name:str-email:strmaintainer:-name:str-email:str
Package: pkg-libpytools
libpytoolsMÃ³dulo para exemplificar construÃ§Ã£o de projetos Python.Neste mÃ³dulo Ã© mostrado como contribuir com cÃ³digos opensource.Link do curso:Python ProPara instalar:python3 -m venv .venvsource .venv/bin/activatepip install -r requiments-dev.txtPara conferir a qualidade do cÃ³digo:flake8TÃ³picos abordados:GitVirtualenvPip
Package: pkglogger
"""Using this Package you can able to track majorly Sysstem Generated followings :1. Log Time
2. Exception
3. Exception Type
4. Exception Object
5. Exception Traceback Summary
6. Exception Traceback Detailed
7. Exception Traceback Line No."""##Steps to run the package :pip install pkglogger==from pkglogger import pkgloggerlogger()'''
You need to call this function at TRY blockVar 1 : Pass the file name you want to create \n
Var 2 : Pass Function name if you want to track function wise logs. To do this, you want keep this call at Function Level\n
Var 3 : If you want to give any specific value as Task Status\n
Var 4 : Path where you want to create the log file. Please pass value as string.\n
Var 5 : If any other parameter you want keep track, pass variable name as you want\n
Var 6 : Pass the value of the additional variable you have added
'''
Example : logger('log3','loggertest','','','URL','http://test.com123')exceptionlogger()'''
You need to call this funcion at EXCEPTION bloackVar 1 : Pass the file name you want to create\n
Var 2 : Pass Function name if you want to track function wise logs. To do this, you want keep this call at Function Level\n
Var 3 : Please pass the exception value. Example : except Exception as e\n
Var 4 : If you want to give any specific value as Task Status\n
Var 5 : Path where you want to create the log file. Please pass value as string.\n
Var 6 : If any other parameter you want keep track, pass variable name as you want\n
Var 7 : Pass the value of the additional variable you have added\n
'''*Return the exception details as well *
Package: pkg-lomo
Example PackageThis is a simple example package by Lomo.Content/Users/lomo/Documents/codes/py_package/pkg_lomo
├──LICENSE
├──README.rst
├──pkg
└──setup.pyChange Log1、First submit, at 2021.11.202、add more func lib3、add some decorator function tools(2021.12.04)4、add one function + test
Package: pkglts
Building packages with long term supportThe rationale behind the creation of this ‘package builder’ is to keep the life
of a python programmer as easy as possible by providing three core functions:A way to add more functionality to an existing package.A way to keep the package structure up to date with currently known best
practices.Remove repetitive tasks that can be automated from the list of things to do.Quick startCreate a virtual environment for development:$ virtualenv dvlptActivate it:$ (on windows)dvlpt\Scripts\activate
$ (on linux)dvlpt/bin/activateInstallpkglts:(dvlpt)$ pip install pkgltsCreate a directory for your package:(dvlpt)$ mkdir totoRun ‘manage’ inside this directory:(dvlpt)$ cd toto
(dvlpt)toto$ pmg init
(dvlpt)toto$ pmg add base
(dvlpt)toto$ pmg regenerateThis will create the bare basic minimum for a python package. Add more options
(see theadd_optionfor more options) afterward. Especially, since in the example
above we just added the ‘base’ option that will create a ‘src’ directory to put
your code in it.DocumentationMore documentation can be found onreadthedocs_pkglts. If you just intend to use this package
you can start with sometutorials. However, if the core functionality are
not sufficient and you want to be part of the development you might be interested
with thedevelopersection of the doc.
Package: pkg-luishidalgogt2003
Covid Data DashboardIntroductionThis project is a Covid Data dashbord that outputs up to date covid data and outputs the latest News Articles, it also can schedule updates and is a fully interactive dashboard.Prerequisitesthis project can be run in any version of python 3 but the ideal isPython 3.8.1Installationinstallation required:py -m pip install --upgrade build, py -m pip install flaskHow to use the projectIn side the folder src you will find the folder package with all the files needed to run the dashboard for every module and each function in each,
module there is clear instructions on how the function works and how to use it.Data RequiredFor the project you will need to include various thing to theconfig.jsonfile so it works such as:Api KeyLocation for the covid dataSearch Terms for the News ArticlesTesting/RunningTo test the code before running it there will be various test modules inside the file directorytests.
To run the code runcovid_user_interface.pyand search"http://127.0.0.1:5000/"in any browserDetailsProject Created byLuis Hidalgo Gutierrez De Tovar,
Licence in file:LICENSE.txtsource code in"index.html"file
acknoledgments to Module LeaderMatt Collisonfor the template ""index.html""
Package: pkgme-devportal
See LICENSE for copyright details.Package dependencies====================* bzr* python-dev* postgresql* postgresql-server-dev-9.1== Building the environment ==Install the above package and then run:"make"to get the environment setup== Testing ==Run "make test" or "make acceptance".To run specific tests you can specify the target via the parameterTEST_TARGET, e.g.:$ make test TEST_TARGET=test_database.TestDatabaseConfigurationConfiguration File==================Behaviour can be controlled by a config file at$HOME/.config/pkgme-binary/confCurrently one section is supported for configuring database access.This can either be sqlite or postgres.You can override the location of this configuration file by setting theenvironment variable ``PKGME_DEVPORTAL_CONFIG_FILE``.Postgres--------The file should look something like::[database]db_type = postgreshost = <db host>port = <db port>username = <db username>password = <db password>db_name = <db name>You will need to create the tables yourself, you can use the``db/postgres_schema.sql`` file for this::sudo -u postgres psql -f db/postgres_schema.sqlContents File (apt-file)------------------------Running in this mode is useful for running locally. It will download thearchives "Contents-%(architecture)s" file on demand and build a localversion of that to map from soname to pkgname.You can run pkgme locally using:$ cd /path/to/binary/thing/you/want/packaged$ echo '{ "package_name" : "mypkg", "description" : "some description" }' > devportal-metadata.json$ PYTHONPATH=/path/to/pkgme:/path/to/pkgme-devport \PKGME_BACKEND_PATHS=/path/to/pkgme-devportal/devportalbinary/backends/ \pkgmeAcceptance tests================There is an acceptance test suite that is not run as part of theunit tests. You can run these tests with:$ make acceptance
Package: pkgme-service-python
pkgme-service-python is a Python client forpkgme-service.  It contains a
synchronous, blocking client.If this sort of thing interests you, you might want to look up:pkgmepkgme-devportalpkgme-service-twistedAutomatic packagingLicensingAll files are Copyright (C) 2012  Canonical Ltd.This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3 of the License.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.Getting helpIf you’d like help with libdep-service, you can find the developers on the#pkgmechannel on Freenode.  Alternatively, join thedeveloper mailing
listand send an email topkgme-devs@lists.launchpad.net.
Package: pkg-metadata
Manage Package MetadataWarning: This project is very early alpha release, so all APIs
could change with little or no notice.Python packages have metadata describing information like the package
name, version, etc. The details of this metadata are defined inthe Packaging User Guide.
When stored in a file (either on the filesystem, or in a package
distribution) the metadata is saved in a format which is based on email
headers.This library transforms that metadata to and from a JSON-compatible
form, as defined inPEP 566.
The JSON form is easier to use in a programming context. Two functions
are provided:msg_to_json(msg)- convert the email header format to JSON.
Themsgargument is the metadata in email format, as anemail.message.Messageobject. Returns a dictionary following
the layout in the "json" form.json_to_msg(json)- convert the JSON form back to email headers.
Thejsonargument is a dictionary following the "json" form.
Returns a (Unicode) string with the message form.Note the discrepancy between the twomsgforms: aMessageobject
and a string. This is something that may change, as it's a bit of
an awkward discrepancy, but there are reasons for this approach:When reading metadata, the file is supposed to be in the UTF-8
encoding, but historically this has not always been the case.
By using aMessageas the input, this can be constructed from
either text or bytes (message_from_stringormessage_from_bytes)
which allows the email package to handle encoding issues. If a
project uses non-UTF8 metadata, it's likely that this approach will
result in mojibake, but at least the data will be usable.When writing metadata, using aMessageobject results in unwanted
header fields, because the object assumes this is a "real" email,
and not just data re-using that format. So it is more reliable
to simply return the output in string format. It can then be written
to a file (in UTF-8) as required.An example of using the library:withopen(metadata_file,"r",encoding="utf-8")asf:msg=email.message_from_file(f)metadata=pkg_metadata.msg_to_json(msg)metadata["keywords"]=["example","artificial"]withopen(metadata_file,"w",encoding="utf-8")asf:f.write(json_to_msg(metadata))In addition to the metadata file format, project metadata can
also be specified in thepyproject.tomlfile, in TOML
format as specified inPEP 621.
This library provides a function to read the[project]section
ofpyproject.tomland convert it into a ("JSON format") metadata
dictionary.pyproject_to_json(pyproject)- convertpyproject.tomlmetadata
into a metadata dictionary. Thepyprojectargument is a dictionary
representing the data in the[project]section ofpyproject.toml.Example:withopen("pyproject.toml","rb")asf:pyproject_data=tomli.load(f)metadata=pkg_metadata.pyproject_to_json(pyproject_data["project"])
Package: pkgmod
pkgmodGet module names from installed package names and back.Example usage:>>>importpkgmod>>>pkgmod.get_package_name("impala")('impyla',False)This returns a tuple with package name and a bool, which tells whether it's
a standard library in Python or not.
For packages this only works if the package is installed.>>>pkgmod.get_module_names("impyla")['impala']>>>pkgmod.get_module_names("Cython")['Cython','cython','pyximport']This returns the module names included in a given package (which also needs to
be installed).