Saravanan666/pypi-org huggingface dataset:
Package: packmon
packmon is a cli tool to monitor aging packages in order to see if somes become obsolete
or updates are availables.PhilosophyAs a simple monitoring tool, packmon is pure-python in order to simplify its use.UsageInstall packmon globally on your systemUse it to detect obsolescence and vulnerabilities in any of your project (virtual
environment or not)ExampleSystem level :pip install packmonThen :packmon myproject/requirements.txt
pip freeze |packmon
curl -s https://raw.githubusercontent.com/AFPy/Potodo/master/requirements.txt |packmonResult :OptionsCache managementThose options help you to manage packages informations from packmon's cache. Cache file
is stored intoHOME_USER/.packmon/packmon.json.clear-cacheSimply delete the cache file.show-cacheShows some informations about actual cache.update-cacheUpdate each package from cache.no-cacheDoes not use cache when using packmon. With this option set, each package will call pypi
to retrieve informations.no-updateDoes not try to refresh a package information, even if it's over than the max dayslimit.Output managementno-colorPackmon will try to display colorized results to help user to see potential problems for
each package. With this option set, no color will be used.quietWith this option set, packmon will write nothing on the standard output (errors will
still be displayed using error output though).only-problemsThis option will limit the results only to obsolete packages.CI compatibilityciWith this option set, packmon will return 1 if any package is obsolete or to update.
Package: packnow
packnowPack everything now. Simple and (maybe) fast.1. Get Packin'$packnow2. Get Hostin'Note: You can also set a password for hosting.$packnowhost--file<zipfile>3. Just Get It!...from other devices or platforms.$packnowget--url<packnowurl>Packignore FilesPretty much just like.gitignore,.packignorefiles will ignore files that are not going to be packed.You could use our default templates, for instance,replit-python, or you can add your own.You'll need to create a new.packignorefile:# .packignore# ignores chocolate.js for any directory*/chocolate.js# for dirs, suffix a slash# ignores __pycache__ dir in any directory*/__pycache__/# ignores wow.cpp in the current dir/wow.cpp# again, for dirs, suffix a slash# ignores directory my-stuff in the current dir/my-stuff/# ignores the specified full path contents# (don't prefix / suffix a slash)go/buy/milkimportant/homework.py
Package: packpath
packpathAutomatically upload Signal stickers from a given path and YAML configurationInstall itThe package is available in PyPI, throughpip:$pip3installpackpathBut you can also simply checkout this repository and run it as a module:$gitclonehttps://github.com/diegoe/packpath.git$cdpackpath$python3-mpackpath(plusarguments,seebelow)How it workspackpathreads a path and loads aconfig.yamlfile from it to automatically
fill asignalstickers-clientclient, and submit stickers.It subclassessignalstickers_client.models.LocalStickerPackto add aload_path()method.You need to provide your username and password, as well as the path to a
sticker directory containing aconfig.yamlfile. See below for details
on both, or runpackpath --help:$packpath--user[uuid_id]--password[password][path_to_sticker_dir]# Most of this README and its instructions are available in the# command's help:$packpath--helpYAML formatThe YAML format is rather simple:pack:title:Your sticker pack titleauthor:An author namecover:filename-for-the-cover.pngstickers:filename.png:👀another-filename.png:👋(...)To save yourself some work, you can uselsto output an almost ready
list of filenames to use on yourconfig.yaml:$ls-1>>config.yamlSignal credentialsFromhttps://github.com/signalstickers/signalstickers-client#uploading-a-pack:You will need your Signal credentials To obtain them, open the
Developer Tools in Signal Desktop, and type
window.reduxStore.getState().items.uuid_id to get your USER, and
window.reduxStore.getState().items.password to get your PASSWORD.The above is also available inpython3 -m packpath --help.CreditsThis is a simple wrapper on top of the very handysignalstickers-client.Go check it out.DisclaimerAll boiler plate disclaimers apply. But also please be respectful of
Signal's service. Don't abuse this or any other script. This is meant to
help legitimate users make the most of the service.DevelopmentMake sure to run flake8 on any changes you make, and also to run the
tests:$flake8packpath$python3-munittestdiscover
Package: packPOOII
packPOOIIPacote utilizado para fazer alterações em arquivos de texto.Instalação:pip install packPOOIIComo usar:from packPOOII import packPOOII
s = packPOOII.PackPOOII()
s.subString(palavra)Funções:subString(): Procura uma sub-string dentro de uma determinada string
deleteLine(): Deleta uma linha de um arquivo de texto
popularidade(): Retorna quantas vezes uma ou mais palavras aparecem em um arquivo de texto
cor(): Retorna a palavra com uma cor escolhida
Package: packpy
packpyAn alternative to pip (uses pip but has more features) to install packages.It stores the package names of the packages that you want to install in a text file called 'requirements.txt', so that if you are migrating to another machine it becomes easier for you to install all the modules that you had previously installed in the older machine.
You just need to carry the 'requirements.txt' file.Installing packpyClone the repository from git and install using setup.py.python setup.py install --userORInstall from pip using:pip install packpyInstalling packages one by one:packpy install <packagename>For Example:packpy install pandas
packpy install idleTime==0.5.0.2Installing packages from requirement.txt:packpy install -r requirements.txtUninstalling packages one by one:packpy uninstall <packagename>For Example:packpy uninstall pandas
packpy uninstall idleTime==0.5.0.2Uninstalling packages from requirement.txt:packpy uninstall -r requirements.txt
Package: packpypi
pacotepypipackpypiÃ© um simples pacote para administrar os dados cadastrados, armazenados e consultados dos usuarios.DependÃªnciasPython 3.6ou posteriorComeÃ§ando o usoÃ‰ necessÃ¡rio que vocÃª instale o pacotepackpypi, para isso basta executar:pip install packpypiFunÃ§Ã£ointeracao ()- Registra o cpf, endereÃ§o e nome do usuÃ¡rioarmazenamento ()- Salva as informaÃ§Ãµes do usuÃ¡rio em um arquivo de textoconsulta ()- Realiza a consulta dos dados do cpf informado atravÃ©s do arquivo de texto
Package: packspec
# packspec-py[![Travis](https://img.shields.io/travis/packspec/packspec-py/master.svg)](https://travis-ci.org/packspec/packspec-py)
[![Coveralls](http://img.shields.io/coveralls/packspec/packspec-py.svg?branch=master)](https://coveralls.io/r/packspec/packspec-py?branch=master)
[![PyPi](https://img.shields.io/pypi/v/packspec.svg)](https://pypi.python.org/pypi/packspec)Cross-language testings made easy: unified YML-based package specification and Python/JavaScript/Ruby/PHP test runners. Read more about the project:https://github.com/packspec/packspec
Package: packstrap
Bootstrap new Python packages with one simple command:packstrap create my_packageWhen starting a Python package a lot of boilerplate is involved. You
have to make several files and directories. When you decide to distribute
your package you have to write a setup.py and reference docs for even the
basics. Packstrap aims to make starting a Python package simpler.Installpip install packstrap
packstrap –helpCreating a PackageWith Packstrap, creating a package is a simple as one command:packstrap create my_package /path/to/code --author "My Name" --plugin git --plugin fabfile --plugin pytestThis will create amy_packagedirectory in/path/to/codewith a structure similar to:/path/to/code/my_package/
    .gitignore
    LICENSE
    MANIFEST.in
    README.rst
    VERSION.txt
    fabfile.py
    setup.py
    src/
        my_package/
            __init__.py
        tests/
            conftest.py
            runtests.pyPackstrap creates the base files for a python project and fills in the basics for setup.py, README.rst, etc.
The git plugin creates.gitignore, the fabfile plugin createsfabfile.py, and the pytest plugin creates thesrc/testsdirectory and files.So now all you have to do is write your module inmy_package, expand on your docs in README.rst, and commit
your package.Set Defaultspackstrap createhas several options to help generate your package. A lot of the options likeauthor,author_email, and evenpluginsare going to be the same for all your projects. To save you some keystrokes you can usepackstrap defaults:packstrap defaults --author "My Name"
{
  "author": "My Name",
  "skeleton": "default"
}You can also usepackstrap defaultswithout options to list the current defaults.
Package: packtab
packTabI first wrote something like this back in 2001 when I needed it in FriBidi:https://github.com/fribidi/fribidi/blob/master/gen.tab/packtab.cIn 2019 I wanted to use that to produce more compact Unicode data tables
for HarfBuzz, but for convenience I wanted to use it from Python.  While
I considered wrapping the C code in a module, it occurred to me that I
can rewrite it in pure Python in a much cleaner way.  That code remains
a stain on my resume in terms of readability (or lack thereof!). :DThis Python version builds on the same ideas, but is different from the
C version in two major ways:Whereas the C version uses backtracking to find best split opportunities,
I found that the same can be achieved using dynamic-programming.  So the
Python version implements the DP approach, which is much faster.The C version does not try packing multiple items into a single byte.
The Python version does.  Ie. if items fit, they might get packed into
1, 2, or 4 bits per item.There's also a bunch of other optimizations, which make (eventually, when
complete) the Python version more generic and usable for a wider variety
of data tables.TODO:Reduce code duplication between Inner/Outer genCode().Handle empty data array.Bake in width multiplier into array data if doing so doesn't enlarge
data type.  Again, that would save ops.If an array is not larger than 64 bits, inline it in code directly
as one integer.Currently we only cull array of defaults at the end.  Do it at
beginning as well, and adjust split code to find optimum shift.Byte reuse!  Much bigger work item.
Package: pack-test
PackTestThis module is designed to provide a strictly in-code implementation of MetaPathFinder that can be leveraged in unit
testing in order to simulate an entry point being created, as would be loaded byimportlib.metadata.entry_points()in Python 3.8+ or byimportlib_metadata.entry_points()in earlier versions.If there are requests, additional functionality aimed at testing plugin packages may be added in future releases.UsageimportunittestimportpacktestclassTest(unittest.TestCase):deftest_me(self):# Could move some of this to be a test fixture instead# Finder on sys.meta_pathfinder=packtest.TestFinder()# Add it to sys.meta_pathfinder.register()# Create a packagepackage=packtest.TestPackage("foobar")# Create entry pointspackage.add_entry_point(# Equivalent to a module with the following in setup.cfg:# [options.entry_points]# myep.group =#     foobar = myep.tests:test.attrpacktest.TestEntryPoint("foobar","myep.group","myep.tests","test.attr"))package.add_entry_point(# Equivalent to a module with the following in setup.cfg:# [options.entry_points]# myep.group =#     foobar2 = myep.tests:test.attr[bar]packtest.TestEntryPoint("foobar2","myep.group","myep.tests","test.attr",["bar"]))finder.add_package(package)# ... do testsConsultationClassesIslandOfferings2# Call this to remove your foobar test packagefinder.remove_package(package)# Remove all packagesfinder.clear()# It is necessary to clean up sys.meta_path after your test case with this:finder.unregister()
Package: packthing
packthingis a high-level integration tool that makes packaging and
distributing your application simple.One project, many formats- quickly produce a versioned distribution for
any project type that’s supported.Configuration is simple- prepare your project for deployment in just a
few steps.Not an expert? Not a problem- save yourself hundreds of hours learning
operating system details; get it done and get on with your life.Installationpackthing is installable viapip:pip install --user packthingpipenvis used for local development:pipenv install --dev
pip install --editable .UsageView the non-existent documentation.ContactSubmit bug reports, suggest features, and view the source onGitHub.
Package: packtree
# packtreepacktree is a Python package that makes ASCII tree representation of apackage's varables or a folder's content.## Table of Contents:* [Author](#author)* [Install and Compile](#install-and-compile)* [Using packtree](#using-packtree)* [Be Kind](#be-kind)* [License](#license)## Author:* [Patricio Cubillos](https://github.com/pcubillos/),  Space Research Institute, Graz, Austria.  <patricio.cubillos@oeaw.ac.at>## Install and Compile### From pipTBD### From GithubClone the repository to your local machine and install it:Clone the repository to your working directory:```shellgit clone https://github.com/pcubillos/packtreepython ./setup.py install```Note that you may need to prepend `sudo` to the previous calls.## Using packtreeThe following demo shows what packtree produces.First start a Python interpreter session:```code>>> import packtree as tree>>> # Genereate the ASCII tree representation of the packtree package:>>> tree.packagetree(tree)packtree|-- filetree`-- packagetree>>> # Generate the ASCII tree representation of the directory that contains the packtree package:>>> tree.filetree(".")packtree|-- LICENSE|-- README.md|-- packtree|   |-- __init__.py|   `-- tree.py`-- setup.py```## Be Kind:Please, be kind and acknowledge and/or refer to the packtree site([github.com/pcubillos/packtree](https://github.com/pcubillos/packtree))if it was useful for you.## License:Copyright (c) 2016 Patricio Cubillos and contributors.packtree is open-source software under the MIT license (see LICENSE).
Package: packworker
bin_packingRead example in example.pyimport random as rd
import binpacking as bp
def create_data_model():
    data = {}
    bins = []
    batches = []
    # number of bins
    nb_bin = 2
    # number of batch
    nb_batch = 3

    for i in range(nb_bin):
        bins.append(
            {
                "length": 20,
                "width": 20,
                "height": 15,
                "index": i,
            }
        )

    for j in range(nb_batch):
        temp = []
        # number of type of item
        nb_item_type = 3
        for i in range(nb_item_type):
            temp.append(
                {
                    "length": rd.randint(1, 5),
                    "width": rd.randint(1, 5),
                    "height": rd.randint(1, 5),
                    "quantity": rd.randint(5, 10),
                    "index": j * 10 + i,
                    "axis_lock": rd.randint(0, 1),
                }
            )
        batches.append(temp)

    # always use 2 key 'bins' and 'batches'
    data["bins"] = bins
    data["batches"] = batches

    return data
# create data for packer
data = create_data_model()

# create packer
packer = bp.create_packer(data)

# pack batch 0 into bin 0
packer.pack(bin_index=0, batch_index=0)

# can draw bin by index to visualize (option)
packer.draw_bin(bin_index=0)

# Get_output
result = []

for bin in packer.bins:
    result.append(bin.packed_items_to_dict())
Package: packy
📦 PackyWhat is packy?Packy is a simple package manager working like pip which allows downloading packages from content delivery providers like cdnjs.How does it work?Install it via pip:pipinstallpackyInstall packages# Latest versionpackyjquery# Specific versionpackyjquery==3.2# Version rangepackyjquery>=2.0# Install from packages.txt (syntax like requirements.txt)packy-rpackages.txt# Set CD providerpacky-pcdnjs...# Set installation directorypacky-o./static/...🔧 APIAdditionally, packy can be used directly with Python:frompackyimportPackypacky.install('jquery')
Package: packyou
packyou=======|Build Status| |Code Health| |Coverage Status|Description-----------Downloads a python project from github and allows to import it fromanywhere. Very useful when the repo is not a packageDemo----.. figure:: https://cloud.githubusercontent.com/assets/568181/18405569/63b0cf9e-76c9-11e6-845e-594101c36136.gif:alt:Introduction------------Sometimes is usefull to be able to import a project from github. If theproject is configured as a python package it could be installed with pipand git. But still lot of project are not using setuptools which makesdifficult to use them from python easily. Some people could be using gitsubmodules, but it also requires adding a **init**.py file in theproject root.With packyou it is possible to import any pure python project fromgithub justo with a simple import statement like:.. code:: pythonfrom packyou.github.username.repository_name import external_github_moduleInstall-------::pip install packyouExample of usage----------------Supose you want to use something from sqlmap project. since sqlmapproyect is not yet a python package you can import anything from sqlmaplike this:.. code:: pythonfrom packyou.github.sqlmapproject.sqlmap.lib.utils.hash import mysql_passwdmysql_passwd(password='testpass', uppercase=True)# '*00E247AC5F9AF26AE0194B41E1E769DEE1429A29'screenshot!-  Free software: MIT license-  Documentation: https://packyou.readthedocs.io.## Features------------  Add support for bitbucket, gitlab.. |Build Status| image:: https://travis-ci.org/llazzaro/packyou.svg?branch=master:target: https://travis-ci.org/llazzaro/packyou.. |Code Health| image:: https://landscape.io/github/llazzaro/packyou/master/landscape.svg?style=flat:target: https://landscape.io/github/llazzaro/packyou/master.. |Coverage Status| image:: https://coveralls.io/repos/github/llazzaro/packyou/badge.svg?branch=master:target: https://coveralls.io/github/llazzaro/packyou?branch=master=======History=======0.1.0 (2016-09-06)------------------* First release on PyPI.
Package: pacman-jogo-teste
Pacman-testeDescricao.
Esse pacote foi criado para:
- Jogar uma replica do jogo pacman.
- Testar e fazer o desafio de projeto do bootcamp.InstalaÃ§Ã£oUse opippara instalar o pacote.pipinstallpacman-jogo-testeComo usarPara rodar o pacote e jogar o jogo, faÃ§a a seguinte importacao.frompacman_teste.jogoimportgamegame.jogar()AutorLucas Emanuel
Package: pacmanprogressbar
Pacman-progressbar==================A ProgressBar for Python, based on Arch progressbar, with `ILoveCandy` option enabled.#### Instalation```bashpip install pacmanprogressbar```#### UsageImport the package and create the bar```pythonfrom pacmanprogressbar import Pacmanp = Pacman()```#### Parameters| Parameter | Default        | Description                                                     || ---       | ---            | ---                                                             || start     | 0              | Initial value                                                   || end       | 100            | Defines the bar's dimension in an amount of items or "steps"    || width     | `console size` | Size (in chars) of the bar, by default is the console size      || step      | 0              | Current position in the progressbar                             || text      | `None`         | Write some text at the beginning of the line                    || encode    | UTF-8          | Encoding                                                        |#### Methods``` pythonp.update([value])```Update the progress, incresing the size by 1, or by the "value" parameter```pythonp.progress([value]):```Set an specified progress, the parameters is mandatory:#### Output----------![Alt text](http://i.imgur.com/7oh3T6x.gif)
Package: pacmimi
pacmimiis an utility to merge two files in themirrorlistformat
used by thepacman package managerinto a single file.Use caseA concrete use case for such an utility is the following:Thepacman package manageruses amirrorlistfile containing
available package mirrors. That file is provided and updated by the
Arch Linux packagepacman-mirrorlist.Themirrorlistfileneedsto be edited by the user in order
to enable (uncomment) at least one mirror. Personally, I enable
multiple mirrors and change their order so that faster mirrors come
first.When thepacman-mirrorlistpackage is updated,pacmanwon’t override
themirrorlistfile with the updated version if it has been edited
by the user (which will always be the case). Instead, the new version
is saved asmirrorlist.pacnew.The user thus needs to manually compare bothmirrorlistfiles and merge
the changes from the newmirrorlist.pacnewfile into his locally modified
copy ofmirrorlistwhile keeping his modifications.An easy way to do this is to just replace the local copy with the updatedmirrorlistand enable and reorder the correct mirrors all over again, but
that gets tedious fast.The last point is wherepacmimicomes in.pacmimirelieves you of that
tedious work – it removes mirrors which are not available anymore from your
localmirrorlistand adds newly added mirrors as disabled (commented)
entries. At the same time, it keeps your enabled mirrors and their order
(it will, however, remove those enabled mirrors which are not present
anymore in the newmirrorlist).InstallationTo installpacmimi, usepip:pip install pacmimiNotepacmimirequires Python 3.Quick startExecute the following command:sudo pacmimi -s /etc/pacman.d/mirrorlist*This will merge yourmirrorlistandmirrorlist.pacnewfiles and removemirrorlist.pacnewwhen it’s done. It backups the originalmirrorlistto/etc/pacman.d/_orig_mirrorlistbefore modifying it.Seepacmimi-hfor available options. The-s(--sane-defaults) option used
above enables useful default options.
Package: pacmine
PacminePacmine makes use of various icons/glyphs from theNerdFontscollection, so any patched fonts are highly recommended. I personally use Fira Code, but you've got options. Full-color terminals are also recommended -- Windows users can use thenew terminal.Installationpipx(Recommended)pipx install pacminePythonpython -m pip install --user pacmineMake sure to add pacmine to your path if user/pipx scripts aren't already.UsageEach command should be prefaced withpacmine. Arguments are shown as{argument_name}. Arguments with ellipses like{mods...}indicate a variable (≥ 1) number of arguments.CommandDescriptionadd {slugs...}Adds 1 or more mods to the local repository, specified by their slugs. Mods cannot be installed multiple times. If you don't know the slug(s), usesearchfirst.remove {slugs...}Removes 1 or more mods from the local repository, specified by their slugs. Mods cannot be removed multiple times, nor removed if they are not installed. If you don't know the slug(s), uselistfirst.updateChecks for and installs any updates to currently installed mods.search {search_term}Searches remote repositories and lists any matches to{search_term}.listLists locally installed mods.dumpDumps a string of slugs for all locally installed mods. Useful withaddfor migrating your mods to another location.new {version} {modloader}Creates a repository in the current directory for version{version}using the{modloader}mod loader. It does this with a file calledmods.pkl, which you shouldn't rename or delete.infoPrints information about pacmine and the local repository, if it exists.Try to avoid deleting files manually from directories managed by pacmine, if possible — pacmine doesn't watch directories to see changes, so it'll become out of sync.