Saravanan666/pypi-org huggingface dataset:
Package: plpydbapi
plpydbapi=========This module provides a (sort of) Python DB-API 2.0 compatibleinterface on top of PL/Python.About DB-API: <http://www.python.org/dev/peps/pep-0249/>About PL/Python: <http://www.postgresql.org/docs/current/static/plpython.html>Installation------------plpydbapi supports Python 2.6 and later, including Python 3.x, andrequires PostgreSQL 9.1 or later.  Using `cursor.description` requiresPostgreSQL 9.2.Just install it like any setuptools-enabled Python module, for examplepython setup.py installor use easy_install.  Make sure you use the Python version that yourinstallation of PL/Python was built against.Using-----Here is an example how to use it:import plpydbapidbconn = plpydbapi.connect()cursor = dbconn.cursor()cursor.execute("SELECT ... FROM ...")for row in cursor.fetchall():plpy.notice("got row %s" % row)dbconn.close()Test suite----------[![Build Status](https://secure.travis-ci.org/petere/plpydbapi.png)](http://travis-ci.org/petere/plpydbapi)There is a test suite in the test/ subdirectory.  It uses the DB-APIcompliance test framework from<https://launchpad.net/dbapi-compliance>.  So first fetch, er, clone,er, branch yourself a copy of thatbzr branch lp:dbapi-complianceinto the current directory.  If you have[mr](http://kitenet.net/~joey/code/mr/), just run `mr up`.If you are using Python 2.6, you also need the unittest2 package; withPython 2.7 and later, the unittest module in the standard library isenough.Then runpython setup.py testThis will run the unittest suite inside the PostgreSQL server,forwarding the output for the client to see.If you have a complicated setup, such as multiple PostgreSQL versionsor nonstandard ports, use libpq environment variables such as PGHOSTand PGPORT to point the test suite driver to an instance it can use.You can also look into the files setup.py andtest/run_test_plpydbapi_dbapi20.sql for some additional ways to tweakthe process.
Package: plpygis
plpygisis a Python tool that can convert aPostGISgeometryinto an equivalent WKB, EWKB, GeoJSON or Shapely geometry.plpygisis intended for use in PostgreSQLPL/Pythonfunctions.Basic usageTheGeometryclass and its subclasses can be used to convert to and from PostGIS geometries. The following example will take a PostGIS multipolygon geometry namedgeomand find its largest component polygon.Geometry()can convert a PostGISgeometrythat has been passed as a parameter to a PL/Python function. AGeometrythat is returned from the PL/Python function will automatically be converted back to a PostGISgeometry.CREATEORREPLACEFUNCTIONlargest_poly(geomgeometry)RETURNSgeometryAS$$fromplpygisimportGeometrypolygons=Geometry(geom)ifpolygons.type=="Polygon":returnpolygonselifpolygons.type=="MultiPolygon":largest=max(polygons.shapely,key=lambdapolygon:polygon.area)returnGeometry.from_shapely(largest)else:returnNone$$LANGUAGEplpython3u;This can then be called as part of an SQL query:SELECTlargest_poly(geom)FROMcountries;DocumentationFullplpygisdocumentation is available athttp://plpygis.readthedocs.io/.
Package: plr-parser
# plr-parserGet the data from the player file and change the data.## Getting StartedFor decryption and encryption you will need openssl, the player file is encrypted with aes-128-cbc algorithm.### PrerequisitesYou need to install the software:` apt installopenssl-tools`### InstallingIt is enough to enter the following command:` pip installplr-parser`or` pipenv installplr-parser`## Running the testsImporting the library` import plr_parser `### Get dataLet’s get the data from the player file:` plr_parser.get_data(file_name: str) `return data:` version: uint32 company: str fileType: uint8 name_lenght: uint8 name: str difficulty: int8 playTime: int statLife: int32 statLifeMax: int32 statMana: int32 statManaMax: int32 extraAccessory: bool taxMoney: int32 armor:dict[{'id':int32, 'prefix': uint8}] acsesuars:dict[{'id':int32, 'prefix': uint8}] dye:dict[{'id':int32, 'prefix': uint8}] inventory:dict[{'id':int32, 'stack': int32, 'prefix': uint8, 'favorites': bool}] `### Get bytes mapFor editing, it is enough to get the raw of all values:` plr_parser.get_bytes_map(file_name: str) `return data:`python dict[bytes_map, source_bytes] `### Save raw bytes to plr fileTo get the player’s working file, you need to encrypt it again:` plr_parser.save(file_name: str, raw_bytes: bytes) `## AuthorsLi-  [Telegram](https://t.me/liriondev)## LicenseThis project is licensed under the GNU General Public License v3.0see the [LICENSE.md](LICENSE.md) file for details
Package: plrs
plrsThe multi-tool of lexical analysis and tokenization.Installpip install plrsBuildmaturin buildExampleszipfs-lawAPIGlobal variablesEOF_TOKENClassesTokens
Settings
Token
  - part
  - token
  - set_part
  - set_token
  - __str__
  - __repr__

Lexer
  - new
  - char_forward
  - skip_over_char_set
  - nextFunctionsis_char_symbol
is_char_operator
is_char_whitespace
is_char_numeric
is_single_quote
is_double_quote
ends_token
is_part_numeric
tokenize
Package: pls
Links:plsis a prettier and powerfullsfor the pros.The "p" stands forpretty (the output fromplssurely looks better)powerful (plshas lots of features and endless customisation)programmer (plsis geared towards developers)professional (plscan be extensively tweaked by the pros)Python (plsis written in Python!)Just pick whichever helps you remember the command name.It works in a manner similar tols, in  that it lists directories and files in
a given directory, but it adds many moredeveloper-friendly features.⚠️ Note thatplsis not a replacement forls.lsis a tried, tested and
trusted command with lots of features.pls, on the other hand, is a simple
tool for people who just want to see the contents of their directories.DocumentationWe have some very beautifuldocumentationover
on our GitHub pages site. These docs are built from thedocsbranchin the same
repository, and contributions to the docs are most welcome.The docs contain information on almost everything, including but not limited to
the following:installation and updatesfeatures and CLI optionsreferencecontribution
Package: pls2upl
pls2upl is a command-line script that will convert a PLS playlist to a UPL
playlist.Quick startYou can install pls2upl with pip:pip install pls2uplOr by cloning the repository and running:python setup.py installYou’re done! Here’s how to use the script:pls2upl myplaylist.pls myplaylist.uplCurrently, for best results it is recommended to tag your music with MusicBrainz
Picard before running this script, otherwise the MusicBrainz identifiers won’t
be added (and those are the most important identifiers)!
Package: plsa
PLSAApythonimplementation of Probabilistic Latent Semantic AnalysisWhat PLSA can do for youBroadly speaking,PLSAis a tool ofNatural Language Processing(NLP). It analyses a collection of text documents (acorpus) under the assumption
that there are (by far) fewertopicsto write about than there are documents
in the corpus. It then tries to identify these topics (in terms of words and
their relative importance to each topic) and to give you the relative
importance of a pre-specified number of topics in each document.In doing so, it does not actually try to "make sense" of each document (or
"understand" it) by contextually analysing it. Rather, it simply counts how
often which word occurs in each document, regardless of the context in which
they occur. As such, it belongs to the family of so-calledbag-of-wordsmodels.In reducing a large number of documents to a much smaller number of topics,
PSLA can be seen as an example of unsuperviseddimensionality reduction,
most related tonon-negative matrix factorization.To give an example, a bunch of documents might frequently contain words like
"eating", "nutrition", "health",etc.Others might contain words like "state",
"party", "ministry",etc. Yet others might contain words like "tournament",
"ranking", "win",etc.It is easy to imagine there being documents that
contain a mixture of these words. Not knowing in advance how many topics there
are, one would have to run PLSA with several different numbers of topics and
see the results to judge how many is a good choice. Picking three in our example
would yield topics that could be described as "food", "politics", and "sports"
and, while a number of documents will emerge as being purely about one of these
topics, it is easy to imagine that there are others that have contributions
from more than one topic (e.g., about a new initiative from the ministry
of health, combining "food" and "politics"). PLSA will give you that
mixture.InstallationThis code is available on the python package indexPyPi.
To install, Istronglyrecommend setting up a new virtual python environment,
and then typepipinstallplsaon the console.WARNING:On first use, some components ofnltkthat don't come with it out-of-the-box
wil be downloaded. Should you install (against my express recommendation) install
theplsapackage system-wide (withsudo), then you lack the access rights
to write the requirednltkdata to where it is supposed to go (into a subfolder of
theplsapackage directory).DependenciesThis package depends on the following python packages:numpymatplotlibwordcouldnltkIf you want to run theexample notebook,
you will also need to install thejupyterpackage.Getting StartedClone theGitHub repositoryand run thejupyternotebookExamples.ipynbin thenotebooksfolder.DocumentationRead theAPI documentationonRead the DocsTechnical considerationsThe matrices to store and manipulate data can easily get quite large. That
means you will soon run out of memory when toying with a large corpus. This
could be mitigated to some extent by using sparse matrices. But since there
is no built-in support for sparse matrices of more than 2 dimensions
(we need 3) inscipy, this is not implemented.
Package: plsc
IntroductionPLSCis an open source repo for a collection of Paddle Large Scale Classification Tools, which supports large-scale classification model pre-training as well as finetune for downstream tasks.Available ModelsFace RecognitionViTDeiTCaiTMoCo v3MAETop News 🔥Update (2023-01-11):PLSC v2.4 is released, we refactored the entire repository based on task types. This repository has been adapted to PaddlePaddle release 2.4. In terms of models, we have added 4 new ones, includingFaceViT,CaiT,MoCo v3,MAE. At present, each model in the repository can be trained from scratch to achieve the original official accuracy, especially the training of ViT-Large on the ImageNet21K dataset. In addition, we also provide a method for ImageNet21K data preprocessing. In terms of AMP training, PLSC uses FP16 O2 training by default, which can speed up training while maintaining accuracy.Update (2022-07-18):PLSC v2.3 is released, a new upgrade, more modular and highly extensible. Support more tasks, such asViT,DeiT. Thestaticgraph mode will no longer be maintained as of this release.Update (2022-01-11):Supported NHWC data format of FP16 to improve 10% throughtput and decreased 30% GPU memory. It supported 92 million classes on single node 8 NVIDIA V100 (32G) and has high training throughtput. Supported best checkpoint save. And we released 18 pretrained models and PLSC v2.2.Update (2021-12-11):ReleasedZhihu Technical ArticalandBilibili Open ClassUpdate (2021-10-10):Added FP16 training, improved throughtput and optimized GPU memory. It supported 60 million classes on single node 8 NVIDIA V100 (32G) and has high training throughtput.Update (2021-09-10):This repository supported bothstaticmode anddynamicmode to use paddlepaddle v2.2, which supported 48 million classes on single node 8 NVIDIA V100 (32G). It addedPartialFC, SparseMomentum, andArcFace,CosFace(we refer to MarginLoss). Backbone includes IResNet and MobileNet.InstallationPLSC provides two usage methods: one is as an external third-party library, and users can useimport plscin their own projects; the other is to develop and use it locally based on this repository.Note: As the PaddlePaddle version continues to iterate, PLSC v2.4 adapts to PaddlePaddle v2.4, and there may be API mismatches in higher versions of PaddlePaddle.Install plsc as a third-party librarypipinstallplsc==2.4Install plsc locallygitclonehttps://github.com/PaddlePaddle/PLSC.gitcd/path/to/PLSC/

gitcheckout-brelease/2.4remotes/origin/release/2.4# [optional] pip install -r requirements.txtpythonsetup.pydevelopSeeInstallation instructions.Getting StartedSeeQuick Run Recognitionfor the basic usage of PLSC.TutorialsConfigurationSee moretutorials.DocumentationData AugmentationSeedocumentationfor the usage of more APIs or modules.LicenseThis project is released under theApache 2.0 license.Citation@misc{plsc,
    title={PLSC: An Easy-to-use and High-Performance Large Scale Classification Tool},
    author={PLSC Contributors},
    howpublished = {\url{https://github.com/PaddlePaddle/PLSC}},
    year={2022}
}
Package: pls-cli
💻 PLS-CLIIf you are like me, and your terminal is your home, this CLI will make your life better, I hope 😄🛠 Installationpipinstallpls-cli⬆️ Upgrade versionpipinstallpls-cli--upgrade⚙️ ConfigurationTo runpls-clieverytime you open your shell's:Bashecho'pls'>>~/.bashrcZshecho'pls'>>~/.zshrcFishecho'pls'>>~/.config/fish/config.fishIonecho'pls'>>~/.config/ion/initrcTcshecho'pls'>>~/.tcshrcXonshecho'pls'>>~/.xonshrcPowershellAdd the following to the end ofMicrosoft.PowerShell_profile.ps1. You can check the location of this file by querying the$PROFILEvariable in PowerShell. Typically the path is~\Documents\PowerShell\Microsoft.PowerShell_profile.ps1or~/.config/powershell/Microsoft.PowerShell_profile.ps1on -Nix.pls⚠️ Restart your terminal to apply the changes and start configuring your PLS-CLI. 🎉⌨️ Commandspls--helpOr for more information you can see in thedocumentation.🎨 Color ConfigurationYou can configure all colors with envs!!Setting env on Linux, macOS, Windows Bash:exportPLS_ERROR_LINE_STYLE="#e56767"Setting env on Windows PowerShell:$Env:PLS_ERROR_LINE_STYLE="#e56767"All envs:exportPLS_ERROR_LINE_STYLE="#e56767"exportPLS_ERROR_TEXT_STYLE="#ff0000 bold"exportPLS_WARNING_LINE_STYLE="#FFBF00"exportPLS_WARNING_TEXT_STYLE="#FFBF00 bold"exportPLS_UPDATE_LINE_STYLE="#61E294"exportPLS_UPDATE_TEXT_STYLE="#61E294 bold"exportPLS_INSERT_DELETE_LINE_STYLE="#bb93f2"exportPLS_INSERT_DELETE_TEXT_STYLE="#a0a0a0"exportPLS_MSG_PENDING_STYLE="#61E294"exportPLS_TABLE_HEADER_STYLE="#d77dd8"exportPLS_TASK_DONE_STYLE="#a0a0a0"exportPLS_TASK_PENDING_STYLE="#bb93f2"exportPLS_HEADER_GREETINGS_STYLE="#FFBF00"exportPLS_QUOTE_STYLE="#a0a0a0"exportPLS_AUTHOR_STYLE="#a0a0a0"exportPLS_BACKGROUND_BAR_STYLE="bar.back"exportPLS_COMPLETE_BAR_STYLE="bar.complete"exportPLS_FINISHED_BAR_STYLE="bar.finished"You can specify the background color like this:exportPLS_QUOTE_STYLE="#a0a0a0 on blue"If you create some theme, share with ushere♥️.💄 Formatting a taskYou can format your tasks with:plsadd"[b]Bold[/], [i]Italic[/], [s]Strikethrough[/], [d]Dim[/], [r]Reverse[/], [red]Color Red[/], [#FFBF00 on green]Color exa with background[/], :star:, ✨"🚧 TMUX integrationUsingpls count-doneandpls count-undone.🤝 Special thanksPLS-CLIstands on the shoulders of giants:Typerfor the CLI tool.Richfor the beautiful formatting in terminal.
Package: plsds
dsplsThis is a Partial Least Squares (PLS) package based on Python.Partial least squares (PLS) is an extension of PCA in which both the  X and Y data are considered. In PCA, only the X data is considered. The goal of the PLS analysis is to build an equation that predicts Y values based on X data.Update0.0.1 Finish the code of Basic PLS0.0.2 Update the KernelPLSDownloadThe requirements are listed in "requirements.txt"Use "pip install git+https://github.com/achrafs758/PLS-from-scratch.git" to install.
Package: plsdsm
dsplsThis is a Partial Least Squares (PLS) package based on Python.Partial least squares (PLS) is an extension of PCA in which both the  X and Y data are considered. In PCA, only the X data is considered. The goal of the PLS analysis is to build an equation that predicts Y values based on X data.Update0.0.1 Finish the code of Basic PLS0.0.2 Update the KernelPLSDownloadThe requirements are listed in "requirements.txt"Use "pip install git+https://github.com/achrafs758/PLS-from-scratch.git" to install.
Package: plserver
Python Live ServerThis repo contains an open source project aimed at helping front end developers.Basic FUnctionalityPython live server helps developer working on frontend to auto reload browser on save. This package is best used with vscode auto save functionality.Getting StartedInstall python live server by typing the following command into the terminal.python3-mpipinstallplserverStart the server the the folder to be used by typing...python3-mplserverCan also be called in a python scriptfromplserver.serverimportmainmain()RequirementsaiohttpLISENSEThis repo is covered underThe MIT LisenseSource CodeThe latest version is avaliable in a Github repository:http://github.com/o-opeyemi/plserver
Package: plsexplain
Create an explainable AI dashboard for your machine learning model. plsexplain,
or please, explain is a question that you may want to ask your computer after
you've trained a machine learning model.Getting startedYou can install this tool as a python package on your machine by using the
following command in your favorite shell:pipinstallplsexplainAfter you've installed the package, use the following command to get an
explainable AI dashboard for your trained model:plsexplain<path-to-model><path-to-sample-set>Currently, we support models trained with scikit-learn, but we're planning on
supporting tensorflow and pytorch as well.The sample set, is a small dataset containing samples you want to use in the
dashboard for explanations based on sample data. We only support using
CSV files at the moment.DocumentationPlease refer to the documentation for more information on how to use the tool
for various types of models and sample datasets.📖 Read the documentationContributingWe welcome contributions to this project. Please refer to the
developer guide for more information on how to submit
issues and pull requests for this project.🛠 Read the developer guideCode of conductPlease make sure to follow ourcode of conductwhen
interacting with other contributors on this project.
Package: plsfix
plsfixplsfix is drop-in replacement forftfy, written in Rust and ~10x faster.>>>fromplsfiximportfix_text>>>print(fix_text("(à¸‡'âŒ£')à¸‡"))(ง'⌣')งInstallingPythonpipinstallplsfixRustcargoaddplsfixWhat it does(Taken from the ftfy README)Here are some examples (found in the real world) of what plsfix can do:plsfix can fix mojibake (encoding mix-ups), by detecting patterns of characters that were clearly meant to be UTF-8 but were decoded as something else:>>>importplsfix>>>plsfix.fix_text('âœ” No problems')'✔ No problems'Does this sound impossible? It's really not. UTF-8 is a well-designed encoding that makes it obvious when it's being misused, and a string of mojibake usually contains all the information we need to recover the original string.plsfix can fix multiple layers of mojibake simultaneously:>>>plsfix.fix_text('The Mona Lisa doesnÃƒÂ¢Ã¢â€šÂ¬Ã¢â€žÂ¢t have eyebrows.')"The Mona Lisa doesn't have eyebrows."It can fix mojibake that has had "curly quotes" applied on top of it, which cannot be consistently decoded until the quotes are uncurled:>>>plsfix.fix_text("l’humanitÃ©")"l'humanité"plsfix can fix mojibake that would have included the character U+A0 (non-breaking space), but the U+A0 was turned into an ASCII space and then combined with another following space:>>>plsfix.fix_text('Ã\xa0perturber la rÃ©flexion')'à perturber la réflexion'>>>plsfix.fix_text('Ã perturber la rÃ©flexion')'à perturber la réflexion'plsfix can also decode HTML entities that appear outside of HTML, even in cases where the entity has been incorrectly capitalized:>>># by the HTML 5 standard, only 'P&Eacute;REZ' is acceptable>>>plsfix.fix_text('P&EACUTE;REZ')'PÉREZ'These fixes are not applied in all cases, because plsfix has a strongly-held goal of avoiding false positives -- it should never change correctly-decoded text to something else.The following text could be encoded in Windows-1252 and decoded in UTF-8, and it would decode as 'MARQUɅ'. However, the original text is already sensible, so it is unchanged.>>>plsfix.fix_text('IL Y MARQUÉ…')'IL Y MARQUÉ…'
Package: plshandle
plshandleCreate an explicit contract between caller and function that requires the caller to handle specific
exceptions raised by the function.WhySometimes, we justhave torecover from an error. And because you are a human being, you might not
always keep exception handling in mind at all times. This tool helps reduce this mental overhead by
reporting all contract violations.HowA simple example:fromplshandleimportplshandle@plshandle(KeyError)defget_item(key):return{}[key]get_item(0)# tool reports this call expression as a contract violationIt is also possible to propagate errors, similar to Java:@plshandle(KeyError)deffoo():returnget_item(0)# o.k., KeyError is propagated, caller's responsibility to handle itNote: This tool performs static analysis only. As such, dynamic constructs are most likely not supported:@plshandle(KeyError)deffoo():passdefbar(callback):callback()# nothing reportedbar(foo)Refer tohttps://plshandle.readthedocs.iofor more in-depth examples.Before committingFetch development dependenciespip -r requirements-dev.txtEnsure there are no linting errorspylintplshandle&&mypy-pplshandleEnsure all tests are successful and code coverage is 100%pytest&&coveragereport--fail-under=100Reformat all filesblackplshandleOr just do this if you have make installedmakecheck
Package: plsl
Pls-LoggingPls-Logging is short for Python Local Server Logging, which refers to a log with a web interface.It uses a modified version ofOh-My-PickleDBJSON Manager for data storing.Pls-Logging is fun and powerfulfromplslimportLogginglog=Logging()# Logging Objectlog.info("info test")# Infolog.warning("warning test")# Warninglog.debug("debug test")# Debuglog.error("error test")# ErrorEasy to Install# Using python pip$pipinstallplsl# Using git$gitclonehttps://github.com/tory1103/pls-logging
$cdpls-logging
$pipinstall-rrequirements.txt
$pythonsetup.pyinstallContributingYou can propose a feature request opening an issue, or a pull request.Here is a list of pls-logging contributors:Useful LinksWebsiteDocumentationPyPi
Package: plsqlunwrap
PLSQL UnwrapA python utility package to unwrap Oracle wrapped objects.Examplefromplsqlunwrapimportunwrapwrapped="""CREATE OR REPLACE  FUNCTION teste wrappeda0000001abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd83d 71m9n4KQ8rT+C9b7lU4HcO3pDzsUMwg8eZgcfLCNL+XhahYtGhXOfAsr2ym16lmYEywLIJpXSLwMAy/tKGCamhBKPHvpK+FkZTOQdTo4KmpqsCL3g="""print(unwrap(wrapped))# FUNCTION teste RETURN NUMBER IS# BEGIN#   RETURN 1;# END TESTE;
Package: plsRe
plsre DocumentationInstallationpipinstallplsreUsagefromplsreimportPlsRegressionasPR# Perform Partial Least_Squared Regression trainingX=np.array([[0.,0.,1.],[1.,0.,0.],[2.,2.,2.],[2.,5.,4.]])Y=np.array([[0.1,-0.2],[0.9,1.1],[6.2,5.9],[11.9,12.3]])P,Q,W,T,B=PR.plsr_train(X,Y)# Perform Prediction using different optimizationprint(PR.plsr_predict(X,Y,P,Q,W,B))print(PR.plsr_predict_numba(X,Y,P,Q,W,B))print(PR.plsr_predict_numpy(X,Y,P,Q,W,B))
Package: plsxml
PLSXMLAboutThis package provides a class for parsing PLS-CADD XML files topandasdata frames for manipulation with Python.InstallationThe package may be installed viapipby running the below command:pip install plsxmlUsageOnce installed, data may be loaded from XML files or ZIP files containing XML
simply by passing the XML and/or ZIP paths to thePLSXMLclass.from plsxml import PLSXML
paths = ['folder1/xml_file.xml', 'folder2/zip_file.zip']
plsxml = PLSXML(paths)The data will be loaded into variouspandas.DataFramebased on the XML file
table names and assigned to the class. For more detailed information, see theexample notebook.PLS-CADD XML FilesMost reports in the PLS-CADD suite can be exported to XML by right-clicking and
selecting the export to XML option. It is also possible to export an XML file
containing data for an entire line through the File menu. XML files for an
entire line can be large (several GB); therefore, archiving the resulting XML
to ZIP can greatly aid in transferring the file across systems and save disk
space if the file is more permanently retained. The PLSXML package is also able
to read data directly from ZIP files for this reason.