Saravanan666/pypi-org huggingface dataset:
Package: plutoplots
PlutoVisualization library foreasier plottingbuilt on top of Seaborn and Matplotlib.If you like the repo, please feel free to give it a :star:  (top right). Cheers!For more information about the author, see below links to get in touch:How to run$ pip install pluto# create custom bar_plot
bar_plot = Barplot()
# configuring custom bar_plot
bar_plot.shape(dim=(10, 5))
    .create('x_col', 'y_col', table, hue='z_col', c=None)
    .grid()
    .spine()
    .tick(left=True, labelleft=True, bottom=True, labelbottom=True)
    .label('x axis', 'y axis', 'title')
    .render()IllustrationsTBI
Package: plutupus
PlutupusPlutupus is a python module to help you create plutus types using python and easily interact with the cardano-cli.It offers you tools such as TxBody, Types, MochaTxBodyTxBody is a module that enables you to build transactions in a simple way. After you are done with it, you can call the method.cli()and it will return the command to type into cardano-cli.TODO
Package: pluvial
pluvialPluvial is a Python package for generating static websites from markdown files, born out of a rainy day project. The name "pluvial" was chosen as a nod to the day the project was started, which happened to be a particularly rainy day.Local SetupInstall MinicondaFor installers for operating systems other than linux seehttps://docs.conda.io/en/latest/miniconda.htmlcurl https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -s --output miniconda.sh
chmod +x miniconda.sh
./miniconda.sh -u
rm miniconda.shCreate conda enviromentYou may need to reopen your shell after installing minicondaconda create -n pluvial python=3.10
conda activate pluvial
conda install --file requirements.txtRun the projectThe default port is 5000python ./app/main.pyDockerBuilding the Docker containerWith your working directory in the root of the repositorydocker build --tag pluvial .Running the Docker containerdocker run -p 5000:5000 pluvialor for detached modedocker run -d -p 5000:5000 pluvialPublishing to dockerdocker login
docker build --tag mullinmax/pluvial:latest .
docker push mullinmax/pluvial:latest
Package: pluxee-api
Pluxee APIThe pluxee-api Python library (unofficial) provides easy access to Pluxee (Sodexo) balance and transaction data. This library allows users to retrieve information such as account balances and transaction history from the Pluxee platform. It offers both synchronous and asynchronous versions for installation.:warning:Belgium only: I could only test this package using my belgian Sodexo card. It should not work for other countries. You can contact me if you need it to work for another country. I will happily improve this package with your help.FeaturesRetrieve account balanceFetch transaction historyInstallationYou can install pluxee-api via pip
For normal install:pipinstallpluxee-apiFor asynchronous version:pipinstallpluxee-api[async]Alternatively, you can clone the repository from GitHub:gitclonegit://github.com/Tib612/pluxee-api.gitcdpluxee-apipipinstall-e.UsageTo use the pluxee-api library, you need to provide your Pluxee username and password or set them as environment variables PLUXEE_USERNAME and PLUXEE_PASSWORD. No registration of keys is required.You can find examples in the example folder.DocumentationDocumentation for pluxee-api is available athttps://pluxee-api.readthedocs.io/en/latest/Questions, Comments, etc?If you have any questions, comments, or suggestions regarding pluxee-api, feel free to contact me on LinkedInhttps://www.linkedin.com/in/thibaut-capuano/ContributingContributions to pluxee-api are welcome! Whether it's adding features, fixing bugs, or improving documentation, your contributions are appreciated. Simply fork the repository, make your changes, and submit a pull request. Let's make accessing Pluxee data easier together!LicenseThis project is licensed under the MIT License
Package: plwrap
PLWRAP - asyncpgplwrapis an easy to use wrapper for Postgresql orientend onjdbi. It isnot an ORM, instead it allows to run SQL queries and dump the result into consistent Python Objects (Dataclasses are prefered)SQL is awesome. Try to remember! :-)Sanic integrationWhen used together with sanic,plwrapuses the sanic logging framework for debugging queriesExamplesimportasynciofromdataclassesimportdataclassimportasyncpgfromplwrapimportquery,one@dataclassclassUser:""" User store """id:stremail:strpwhash:strclassUserDAO:""" some sort of database access object """@staticmethod@one@query(User)asyncdefget_by_email(email:str)->User:""" Tries to get a user based on its email (unique) """return"select id, email, pwhash from users where email = $1",emailasyncdefmain():db_pool=awaitasyncpg.create_pool(database="what",user="ever")user=awaitUserDAO.get_by_email(db_pool,"me@xvzf.tech")print(user)if__name__=="__main__":asyncio.get_event_loop().run_until_complete(main())
Package: plxcontroller
plxcontrollerControllers to create and modify Plaxis 2D and 3D models with enhanced functionalities.This repository is created byCEMS BV.InstallationTo install a package in this repository run:$ pip install plxcontrollerContributionEnvironmentWe recommend developing in Python3.9 with a clean virtual environment (usingvirtualenvorconda), installing the requirements from the requirements.txt file:Example usingvirtualenvandpipto install the dependencies in a new environment .env on Linux:python-mvenv.envsource.env/bin/activate
python-mpipinstall--upgradepipsetuptools
pipinstall-rrequirements.txt
pipinstall-e.FormatWe format our code with black and isort.black--config"pyproject.toml"src/plxcontrollertestsnotebooks
isort--settings-path"pyproject.toml"src/plxcontrollertestsnotebooksLintTo maintain code quality we use the GitHub super-linter.To run the linters locally, run therun_super_linter.shbash script from the root directory.UnitTestTest the software with the use of coverage:python-mpipinstall--upgradepipsetuptools
pipinstall-rrequirements.txt
pipinstall-e.
coveragerun-mpytestRequirementsRequirements are autogenerated by thepip-compilecommand with python 3.9Install pip-tools with:pipinstallpip-toolsGenerate requirements.txt file with:pip-compile--extra=test--extra=lint--output-file=requirements.txtpyproject.tomlUpdate the requirements within the defined ranges with:pip-compile--upgrade--extra=test--extra=lint--output-file=requirements.txtpyproject.toml
Package: plxscripting
plxscriptingPython files required to interact with PLAXIS API. These files are created by
Seequent/Bentley (owner of PLAXIS) and distributed as part of the PLAXIS
installation. The goal of this repository is simply to store this files to ease
the CEMS development pipeline.InstallationTo install simply run:$ pip install plxscriptingOr for a particular version (e.g. 1.0.2):$ pip install plxscripting==1.0.2Compatibility tables between Plaxis program version and repo versionEach version of this repository is compatible with one (or more) versions of
the PLAXIS 2D and 3D programs. Below you find two tables containing the
known compatibilities, so you can install the version you need depending on
the PLAXIS program you need to use.PLAXIS 2D VersionsRepository VersionPLAXIS 2D CONNECT Edition V22 Update 21.0.2PLAXIS 3D VersionsRepository VersionPLAXIS 3D 2023.21.0.4ContributionDeveloper's noteEvery time a new PLAXIS version is released, a new version of theplxscriptingdirectory and theencryption.pyfile is released/included in
the PLAXIS installation. Theses files are typically located under a directory similar to:C:\ProgramData\Seequent\PLAXIS Python Distribution V2\python\Lib\site-packageswhereSeequentused to be namedBentleyin the previous versions andV2will have a different index.The contribution of this repository restricts itself to:Copy the copy these files toplxscriptingdirectory and theencryption.pyunder
thesrcof this repository.Make a new release using the same version as in the fileplxscripting\__version__.py.Updating the compatibilty tables writter in the previous section.EnvironmentWe recommend developing in Python3.9 with a clean virtual environment (usingvirtualenvorconda),
installing the requirements from the requirements.txt file:Example usingvirtualenvandpipto install the dependencies in a new environment .env on Linux:python-mvenv.envsource.env/bin/activate
python-mpipinstall--upgradepipsetuptools
pipinstall-rrequirements.txt
pipinstall-e.RequirementsRequirements are autogenerated by thepip-compilecommand with python 3.9Install pip-tools with:pipinstallpip-toolsGenerate requirements.txt file with:pip-compile--extra=test--output-file=requirements.txtpyproject.tomlUpdate the requirements within the defined ranges with:pip-compile--upgrade--extra=test--output-file=requirements.txtpyproject.toml
Package: ply
PLY is yet another implementation of lex and yacc for Python. Some notable
features include the fact that its implemented entirely in Python and it
uses LALR(1) parsing which is efficient and well suited for larger grammars.PLY provides most of the standard lex/yacc features including support for empty
productions, precedence rules, error recovery, and support for ambiguous grammars.PLY is extremely easy to use and provides very extensive error checking.
It is compatible with both Python 2 and Python 3.
Package: plyball
Overviewplyballis a Python package providing a extracting data from several of
the most popular baseball sources (Fangraphs, Statcast, etc...). A majority
of these sources are scraped.Where to get itThe source code is currently hosted on GitHub at:https://github.com/waaronmorris/plyballBinary installers for the latest released version are available at thePython
package index.pipinstallplyballDocumentationThe official documentation is hosted on ReadtheDocs.org:https://plyball.readthedocs.io/DependenciesPython (>= 3.6)beautifulsoup4 (>= 4.9.3)lxml (>= 4.6.3)pandas (>= 1.2.4)requests (>= 2.25.1)tqdm (>= 4.60.0)unidecode (>= 1.2.0)urllib3 (>= 1.26.4)xlrd (>= 2.0.1)xlwt (>= 1.3.0)openpyxl (>= 3.0.7)
Package: ply-bibtex-parser
ply-bibtex-parserA simple ply-based parser for BibTeXplyis an easy-to-use, pure-Python parser generator. However
it's not the most modern or performant tool.This is mostly an academic exercise into writing a simple parser, but I used it in my personal website in order to parse
a.bibfile to identify the different citations and write them back after reformatting
them.Installpip install ply-bibtex-parserUsageParsingThe main entry point is throughparser:fromply_bibtex_parserimportparserinput='@article{citekey, author={Smith, Micah J.}, title={Foo bar}}'parser.parse(input)# [BibtexEntry(type='article', key='citekey', fields={'author': '{Smith, Micah J.}', 'title': '{Foo bar}'})]The parser produces a possibly-empty list ofBibtexEntryobjects. Note that values in
the entry which are usually delimited with braces contain the braces: this makes it easy to
write back the bibtex entry without trying to escape its contents. The caller is responsible
for further parsing the values if they intend to use the string after escaping is performed.LexingYou can also use thelexerdirectly:fromply_bibtex_parserimportlexerinput='@article{citekey, author={Smith, Micah J.}, title={Foo bar}}'lexer.input(input)fortokinlexer:print(tok)# LexToken(AT,'@',1,0)# LexToken(ID,'article',1,1)# LexToken(ENTRYBEGIN,'{',1,8)# LexToken(ID,'citekey',1,9)# LexToken(COMMA,',',1,16)# LexToken(ID,'author',1,18)# LexToken(EQUALS,'=',1,24)# LexToken(VALUE,'{Smith, Micah J.}',1,41)# LexToken(COMMA,',',1,42)# LexToken(ID,'title',1,44)# LexToken(EQUALS,'=',1,49)# LexToken(VALUE,'{Foo bar}',1,58)# LexToken(ENTRYEND,'}',1,59)DevelopmentInstallpip install poetry
poetry installCheckinv test lintLimitationsSee the TODO notes in./ply_bibtex_parser/lexer.pyand./ply_bibtex_parser/parser.py.
Package: plyder
plyderDownload manager with web-interface.Installation$pipinstallplyderUsage$plyderplyderworks out of the box. Though you might want to adapt the configuration to your taste.Custom download scriptsCustom download scripts can be specified in the configuration file:download_handlers:-./github_downloader.sh./github_downloader.shneeds to be an executable script of the following form:#!/usr/bin/env bash# PLYDER_HOST: <host to match>url="$1"output_dir="$2"<customlogic>Seeplyder/download_providers/for built-in examples.Prometheus integrationplyderexposes the/metricresource which allows monitoring download counts and system usage usingPrometheusand, e.g.,Grafana.
Package: plyfile
Welcome to theplyfilePython module, which provides a simple facility
for reading and writing ASCII and binary PLY files.Quick startTo install the latest official release:pip3 install plyfileTo install from source:# From the project root
pip3 install .Quick linksPLY format referenceLinkProject documentationLinkGetting helpHave questions? Feel free to ask inDiscussions.Reporting bugsIssuesContributingInformation for developersCopyright and licenseCopyright Darsh Ranjan andplyfileauthors.This software is released under the terms of the GNU General Public
License, version 3.  See the fileCOPYINGfor details.
Package: plyflatten
PlyFlattenTake a series of ply files and produce a digital elevation mapInstallationpip install plyflattenUsageThis package comes with a command-line tool:$ plyflatten --help
usage: plyflatten [-h] [--resolution RESOLUTION]
                  list_plys [list_plys ...] dsm_path

plyflatten: Take a series of ply files and produce a digital elevation map

positional arguments:
  list_plys             Space-separated list of .ply files
  dsm_path              Path to output DSM file

optional arguments:
  -h, --help            show this help message and exit
  --resolution RESOLUTION
                        Resolution of the DSM in meters (defaults to 1m)Try using it on the test data provided with the repository:plyflatten tests/data/{1,2}.ply out.tiff --resolution 2ContributingTo work on this project, install the development requirements by running:make installThe tests can be run with:make test
Package: plyj
plyj [![Build Status](https://secure.travis-ci.org/musiKk/plyj.png?branch=master)](http://travis-ci.org/musiKk/plyj)====plyj is a Java parser written in Python. It has the awesome [PLY] as its sole dependency.Synopsis--------```pythonimport plyj.parser as plyjparser = plyj.Parser()# parse a compilation unit from a filetree = parser.parse_file(file('/foo/bar/Baz.java'))# parse a compilation unit from a stringtree = parser.parse_string('class Foo { }')# parse expression from stringtree = parser.parse_expression('1 / 2 * (float) 3')# slightly bigger example: parse from an installed JDK with sourcesimport zipfilesrczip = zipfile.ZipFile('/usr/lib/jvm/java-6-openjdk/src.zip', mode='r')info = srczip.getinfo('java/lang/Object.java')srcfile = srczip.open(info)tree = parser.parse_file(srcfile)```Acknowledgement---------------plyj is more or less a 1:1 translation of the grammar used in the [Java Development Tools] for Eclipse.Completeness------------The grammar is complete. There may still be errors left though. It successfully parsed every source file of the Oracle JDK. A lot of bugs were found that way but for all I know there may be many more. Time will tell.Contributions-------------Contributions are always welcome. Depending on the type of work it maytake a little while until I get around to accepting them.* commit test that demonstrates a bug (optional)* commit the fix* open pull requestThe test is required but does *not* have to be provided by you. If youdo provide it, committing it first shows appropriate messages in thepull request and makes it easier to accept via Web.Performance-----------A word of caution: Since plyj is pure Python, it is quite slow. Based on my laptop (which has an i7-3517U @ 1.90 GHz) I can present the following numbers (running inside a virtual machine):* 619 rules* 1149 states* ~3.28 seconds to compile the grammar* java/util/Collections.java takes ~0.44 seconds to parse (it's quite big though)The timings are obviously highly dependent on the used hardware. My old laptop (Core 2 Duo @ 1 GHz) took 17 and 1.8 seconds respectively.[PLY]: https://github.com/dabeaz/ply[Java Development Tools]: http://www.eclipse.org/jdt/
Package: plymgf
This project allow you to read/parse MGF files.If you find a bug, have a problem to parse a MGF file or
have a feature request please crease an issue on github (https://github.com/Astyan-42/plymgf) and provid the MGF file causing the issueit’s use like :from plymgf.mgfreader import MGFReaderres = MGFReader(‘path_to_your_file.mgf’)To have the same behaviour than in previous versions dodata = res.get_raw_data()You can get some metadata with the methods:get_cleget_accessionget_itolget_itoluget_massget_precursorget_segget_taxonomyget_usermailget_chargeBy default you are on the first ions;
To go on the next one use the method “next_ion”.
If you are on the last ions the method will also return 1.You can get some ions data with the methods:get_ion_chargeget_ion_pepmassget_ion_rtinsecondsget_ion_seqget_ion_titleget_ion_tolget_ion_toluget_ion_peaks
Package: ply-parser
PLY File ParserThis Python module provides a simple PLY (Polygon File Format) file parser. It includes a class PLYObject for storing PLY file data and a function parse_ply_file for reading PLY files and creating PLYObject instances.UsagePLYObject ClassThe PLYObject class represents a PLY object with attributes:name: Name of the PLY object.vertices: List of vertex coordinates.faces: List of face indices.colors: List of RGB color values for vertices.parse_ply_file FunctionThe parse_ply_file function takes a PLY file as input and returns a PLYObject instance. It reads the file, extracts vertex and face information, and handles color properties. If any inconsistencies or errors are detected in the PLY file, appropriate error messages are displayed.file = "data/cube_colors.ply"
parsed_object = parse_ply_file(file)
if parsed_object:
    print("name:", parsed_object.name)
    print("total_vertices:", len(parsed_object.vertices))
    print("total_faces:", len(parsed_object.faces))
    print("total_colors:", len(parsed_object.colors))RequirementsPython 3.11.xPLY File Format SupportThis parser currently supports PLY files with the following characteristics:ASCII formatVertex coordinates (X, Y, Z)Face indices (triangles and quads)Vertex colorsTestingpython3 -m unittest tests/test_ply_parser.py -vLimitationsThe parser assumes the input PLY file follows the standard specifications.
It may not handle non-standard or corrupted PLY files gracefully.ContributionFeel free to contribute by opening issues or submitting pull requests. Bug reports, suggestions, and improvements are welcome.LicenseThis PLY file parser is licensed under the MIT License. See the LICENSE file for details.
Package: plypatch
Descriptionplyis a utility to manage a series of patches against an upstream
project.  These patches are stored as files in a separate git repositiory so
that they can themselves be versioned. These patches can then be applied to
create a patched version of the code to be used for packaging and deployment.ConceptsThe upstream project resides in theupstream-repo(UR). Your local
checkout of theupstream-repois called theworking-repoand is where
you’ll do most of your work: you’ll make changes, commit them, and then runply saveto create a new set of patches, called apatch-series.The patches are stored in thepatch-repo(PR), a separategitrepo
that is linked to theworking-repousing theply.patchrepogitconfig.UsageInitialize a newpatch-repowhich initializes the newgitrepo and
commits an emptyseriesfile:ply init .Linkworking-repoto apatch-repo:ply link ../my-patch-repo  # from within the working-repoUnlinkworking-repofrom currentpatch-repo:ply unlinkCheck that status of aworking-repo:ply status
All patches appliedSave set of commits to thepatch-repo:# Without --since, any 'new' patches (patches that follow applied patches)
# will be saved
ply save

# Save only the last commit into the 'foo' subdirectory
ply save --since=HEAD^ --prefix=foo HEAD^Rollbackworking-repoto match upstream:ply rollbackRestorepatch-series:ply restoreResolve a failed merge and continue applyingpatch-series:ply resolveSkip a patch that has already merged upstream. In addition to performing agit am--skip, this will also remove the relevant patch from thepatch-repo:ply skipNote: If the upstream patch is an exact match of the version in thepatch-repo,plywill automatically remove the patch from thepatch-repo.Perform a health-check on thepatch-repo. This ensures that all of the
patches in thepatch-repoare accounted for in thepatch-series:ply check
OKCreate aDOT graphrepresentation of patch dependencies:ply graphThe output of this can be piped intodotto generate a PNG file:ply graph | dot -Tpng > dependencies.pngplyvs X?Tools for managing patches have existed for a while, so why create another?The short answer is:quiltdeals in patch-files which can be versioned but doesn’t understand
version-control. This orthogonality, in some respect, is elegant, but is a
hassle in day-to-day use. Why checkpoint files inquiltwhen your version
control system already does that for you?stgit(stacked-git) understands version control but stores patches as
commit objects, not as patch files. This means you can’t version your patches,
making it impossible to rollback when things go awry.plyblends these two tools together to create a tool that understands
version-control but at the same time stores patches as files which can
themselves be versioned.
Package: plyto
# plyto[![Binder](http://beta.mybinder.org/badge.svg)](https://mybinder.org/v2/gh/jupytercalpoly/plyto/master)Python Visualization Toolkit for Machine Learning and Data Exploration## Prerequisites for Model Visualization- JupyterLab- Statusbar Extension## Prerequisites for Data Exploration- JupyterLab- Pandas- Altair## Usage- Open model visualizations from the toolbar or status bar (if model is training)- Use data exploration functions with```pythonfrom plyto import check_data, check_column```## Install## Development### Contributing### InstallRequires node 4+ and npm 4+```bashgit clone https://github.com/jupytercalpoly/plyto.gitcd plytonpm installnpm run buildjupyter labextension link .```To rebuild the package and the JupyterLab app```bashnpm run buildjupyter lab build```
Package: plyvel-wheels
Why does this fork exist?The sole reason for this fork existing is to provide cross platform wheels for
ease of installation - Namely on Mac and Windows which do not currently have bundled leveldb
libraries. (This repo was previously named plyvel-win32 as it was only for windows)In other words, I am compiling the C++ leveldb -> x86-64 binaries + doing
the cython build and wheel creation so that you don’t have to. I have no intention
of doing any development work on plyvel beyond this - please continue to use
the main repository for all other purposes.To install:>py-3.9-mpipinstallplyvel-wheelsThen use like you normally use plyvel:importplyveldb=plyvel.DB('/tmp/testdb/',create_if_missing=True)Note:There is a single failing test for windows:test_open_read_only_dirWhere there is a discrepancy in the type of error message that is thrown when trying to access a
db in a read-only directory. I am unsure if this is of any significance in practice.PlyvelPlyvelis a fast and feature-rich Python interface toLevelDB.Plyvel has a rich feature set, high performance, and a friendly Pythonic API.
See the documentation and project page for more information:DocumentationProject pagePyPI pageNote that using a released version is recommended over a checkout from version
control. See the installation docs for more information.