Saravanan666/pypi-org huggingface dataset:
Package: plums
PLaygroundMLUnifiedMicrolibSet : ThePlayground MLpythontoolboxpackageThe Plums library set aims to defined a common set of packages to be used by people involved in thePlaygroundML team.Those packages puropose is to set a unique baseline to help make the code base more unified and avoid countless reimplementation of the same tools which in turns make people waste time and make the code base herd to understand,
debug and reuse.Installation is simple withPyPIrepository:pipinstallplums[TODO]
More information on installation can be found in theGetting Startedsection of the documentation.Documentation and tests specific dependencies can be installed with thedocsandtestsextra keywords respectively.PackagesCommonsThe Plumscommonspackage aims to offer a set of lightweight highly
reusable classes and utilities for all other packages.To import do:importplums.commonsPlotThe Plumsplotpackage aims to offer a set of lightweight highly
reusable classes and utilities for visualizing detection and segmentation
results.To import do:importplums.plotModelThe Plumsmodelpackage aims to offer a framework-agnostic model
format specification (thePlumsModelFormat) along with its
python representation and helper implementation to ease integration into
producer and consumer codebases.To import do:importplums.modelDataflowI/Ooperations and efficientdatasetiteration and indexing
handling.To import do:importplums.dataflowObjectivesDataflowDataflow elements to speedup future developements: e.g.Datasetclasses,Samplerand/orDataloader(?) and handle augmentation (imgaug,albumentation,pure numpy?)Python representation of data elements (e.g.Annotation,Feature,Image,Datapoint...)Datasetclasses for playground datasetsTranformedDataset-like classes to manipulate, combine and transform (e.g. augmentations) datasets in an online fashionSamplerandBatchSamplerclasses to port PyTorch functionalities into Keras and build upon themData-preparationLoop through datasets in a multi-threaded or multi-processed fashionSome convenient data-preparation functions such as image transformations or annotations refinementSome convenient statistic and analysis toolsVisualisationPlot annotation on imageHandle single image and image gridsPlot differentials and/or superposition of annotations on same imagesHandle multiple color code mode, e.g.:By labelBy confidenceBy sizeBy type (in differential plotting)And possibly combination of examples above (e.g. Color by label and shades by confidence)Model Format (UMF like ?)Python representation of a model and its format componentsIO functionalities, e.g.:Save a model (as collect disparate resources into a coherent model directory w/ metadata)Load a model (as create a Python model representation w/ metadata from a model directory)Verify an existing model directoryCopy and/or prune a model
Package: plumstats
# Inflector for PythonThe Inflector is used for getting the plural and singular form of nouns. This piece of code helps on creating code that favors convention over configuration.Only English and Spanish nouns are supported. The English version is a port of Ruby on Rails Inflector, while the Spanish Version has been developed from scratch with the help of Carles Sadurní.Apart from converting singulars and plurals, this module also handles necessary string conversion for convention based applications like:Available methods are:## pluralize(word)Pluralizes nouns.## singularize(word)Singularizes nouns.## conditionalPlural(numer_of_records, word)Returns the plural form of a word if first parameter is greater than 1## titleize(word, uppercase = ‘’)Converts an underscored or CamelCase word into a sentence.
The titleize function converts text like “WelcomePage”,
“welcome_page” or  “welcome page” to this “Welcome Page”.
If the “uppercase” parameter is set to ‘first’ it will only
capitalize the first character of the title.## camelize(word):Returns given word as CamelCased
Converts a word like “send_email” to “SendEmail”. It
will remove non alphanumeric character from the word, so
“who’s online” will be converted to “WhoSOnline”## underscore(word)Converts a word “into_it_s_underscored_version”
Convert any “CamelCased” or “ordinary Word” into an
“underscored_word”.
This can be really useful for creating friendly URLs.## humanize(word, uppercase = ‘’)Returns a human-readable string from word
Returns a human-readable string from word, by replacing
underscores with a space, and by upper-casing the initial
character by default.
If you need to uppercase all the words you just have to
pass ‘all’ as a second parameter.## variablize(word)Same as camelize but first char is lowercased
Converts a word like “send_email” to “sendEmail”. It
will remove non alphanumeric character from the word, so
“who’s online” will be converted to “whoSOnline”
return self.Inflector.variablize(word)## tableize(class_name)Converts a class name to its table name according to rails
naming conventions. Example. Converts “Person” to “people”## classify(table_name)Converts a table name to its class name according to rails
naming conventions. Example: Converts “people” to “Person”## ordinalize(number)
Converts number to its ordinal form.
This method converts 13 to 13th, 2 to 2nd …## unaccent(text)Transforms a string to its unaccented version.
This might be useful for generating “friendly” URLs## urlize(text)Transform a string its unaccented and underscored
version ready to be inserted in friendly URLs## foreignKey(class_name, separate_class_name_and_id_with_underscore = 1)Returns class_name in underscored form, with “_id” tacked on at the end.
This is for use in dealing with the database.
Package: plunchy
plunchyis a simple interface into OS X’slaunchctl. It is based on the idea behind Mike Perham’slunchy(link) Ruby script, though there are a few small differences between the two:By default,plunchydoes not install items into the system’sLaunchAgentsfolders. Unless you jump through hoops, items in those folders are automatically started at system boot, defeating the purpose of managing startup and shutdown for your launch agents.Also by default, if you do want a file to be installed in aLaunchAgentsfolder,plunchywill symlink the file, rather than copy it. This allows you to automatically receive updates if the launch agent is updated.plunchydoes want to maintain the simplicity of the original, however, so the available commands largely mirrorlunchy’s:ls [pattern]List all launch agents, or only ones matching the given pattern.list [pattern]Alias forlsstart {pattern}Start the launch agent matching the given pattern.stop {pattern}Stop the launch agent matching the given pattern.restart {pattern}Restart the launch agent matching the given pattern.status {pattern}Display the status of all launch agents matching the pattern.show {pattern}See the launch agent with the specified patternedit {pattern}Edit the launch agent with the specified patternThe main area whereplunchydiffers, however, is in the installation of scripts.plunchyprovides the following commands for installing scripts:install {path}Add the agent to~/.plunchyto be started/stopped manuallylink {path}Install the agent into~/Library/LaunchAgentsvia symlink (*)copy {path}Install the agent into~/Library/LaunchAgentsvia file copy (*)(*) Doing this means the launch agent will be loaded/started when the system boots up.InstallationThe easiest way to installplunchyis viapip:pip install plunchyLicenseplunchyis MIT licensed. Please see the includedLICENSEfile.AuthorsBill Israel -@epochblue-http://billisrael.info/Marc Abramowitz -@msabramo-http://marc-abramowitz.com/
Package: plunetapi
PlunetAPIThin wrapper for the Plunet SOAP API.About The ProjectA thin wrapper to facilitate interactions with the PlunetAPI.(back to top)Built WithzeepPlunet(back to top)Getting StartedInstallationClone the repogitclonehttps://github.com/kuhnemann/plunetapi.gitOr install via pippipinstallplunetapi(back to top)UsageInstall using pip like so:pipinstallplunetapiThe wrapper is thin by design and intended to be used by a client. For example something along these lines:fromplunetapiimportPlunetAPI
fromtypingimportUnion,Callable

classPlunetClient:def__init__(self,base_url:str):self.plunet=PlunetAPI(base_url=base_url)self.uuid=Nonedeflogin(self,username:str,password:str):uuid=self.plunet.PlunetAPI.login(username,password)ifuuid=="refused":raiseConnectionRefusedError("Login refused")else:self.uuid=uuiddef_make_request(self,operation_proxy:Callable,argument:Union[dict,str,int,list]):result=operation_proxy(self.uuid,argument)ifresult.statusCode!=0:raiseException(result.statusMessage)else:returnresult.datadefget_customer_object(self,customer_id:int):data_item=self._make_request(self.plunet.DataCustomer30.getCustomerObject,customer_id)returndata_itemAs a complement to the Plunet JavaDocs, use the propagated zeep factory method to explore objects as definied in the different WSDLs. For example:plunet=PlunetAPI(base_url=base_url)plunet.DataJob30.factory.PriceLine(){'amount':None,'amount_perUnit':None,'memo':None,'priceLineID':None,'priceUnitID':None,'sequence':None,'taxType':None,'time_perUnit':None,'unit_price':None}(back to top)See theopen issuesfor a full list of proposed features (and known
issues).(back to top)ContributingContributions are what make the open source community such an amazing place to learn, inspire, and create. Any
contributions you make aregreatly appreciated.If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also
simply open an issue with the tag "enhancement". Don't forget to give the project a star! Thanks again!Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull Request(back to top)LicenseDistributed under the MIT License. SeeLICENSEfor more information.(back to top)ContactHenrik Kühnemann -@hkuhnemann-hello@yellownape.seProject Link:https://github.com/kuhnemann/plunetapi(back to top)(back to top)
Package: plunge
PlungePlunge encompasses some additional features that facilitate exploratory data analysis. It takes advantage of the resources of widely known data science libraries, such as NumPy, Pandas, Matplotlib, Seaborn, and Scikit-Learn.Instalation (Google Colaboratory):To integrate Plunge into your Google Colaboratory environment, use the following pip command:!pip install plungeTo ensure you have the latest version:!pip install --upgrade plungeHow to import (Google Colaboratory):Once installed, importing Plunge is straightforward. Use the following Python code in your Google Colaboratory notebook:import plunge as pgAbout the DeveloperFor feedback, questions, or collaboration, feel free to reach out:LinkedIn:Gustavo Ortiz
Package: plunger
A tool to inspect and clean gitlab’s docker registry.InstallationUsing pip:$ pip install plungerExamplesFirst export some env var to avoid reapeating command line arguments:$ export PLUNGER_REGISTRY=https://your.gitlab.registry/
$ export PLUNGER_KEY_FILE=/path/to/your/keyInspect the registry:$ # show size used by images, grouped by gitlab group
$ plunger --list 1

$ # show sizes only for a group
$ plunger --list 2 --filter repository/

$ # show sizes of all tags
$ plunger --list 0 --filter repository/path/Remove some images:$ # keep 4 latest tags for each repos
$ plunger --keep 4

$ # keep 2 latest tags for repos starting with 'repository/'
$ plunger --keep 2 --filter repository/

$ # remove all tags for repos starting with 'repository/path/'
$ plunger --keep 0 --filter repository/path/
Package: plupload
bottlepy-plupload=================Uploading multiples files using plupload js library and bottlepy as never been easier.Setup virtualenv=================```virtualenv dev. dev/bin/activatepip install bottle```Run multiple upload with plupload and bottle=================```. dev/bin/activatepython bottle-example.py```Save uploaded files in your Python code=================```from bottle import request, postfrom plupload import plupload@post('/upload')def index():return plupload.save(request.forms, request.files, "/destination/folder")```
Package: pluplusch
This goes through all the datasets I know about.for dataset in pluplusch():
    print(dataset)You can tune it a bit with the parameters.pluplusch(catalogs = ['http://data.enseignementsup-recherche.gouv.fr'],
          cache_dir = '/lockers/tlevine_vol/dadawarehouse.thomaslevine.com/big/pluplusch')If you want to save the data catalog metadata every so often, you might
write a crontab that looks like this.@weekly pluplusch --cache-dir ~/$(date --rfc-3339=date)
Package: plur
plur: 🔢 simple universal word pluralizer 🔢Tired of seeing1 branch(es) deleted?Sick ofes = '' if len(branches) == 1 else 'es'
print(f'{len(branches) branch{es} created')or even worse?Tryplurfor your tiny pluralization needs:import plur

print(plur('branch', '-es'), branches), 'created)No dictionary file!No dependencies!No salesperson will call!Examples:import plur

dogs = ['fido', 'rover']
print(plur('dog', dogs))  # prints: 2 dogs

dogs.pop()
print(plur('dog', dogs))  # prints: 1 dog

dogs.pop()
print(plur('dog', dogs))  # prints: 0 dogs

# Great for f-strings

dogs = 'fido', 'rover'
print(f'Today we have {plur("dog", dogs)}')For words you use a lot, you can defer operation:dog = plur('dog')
cat = plur('cat')
ox = plur('ox', '-en')

print(dog(dogs), 'live in my house with', ox(ox_list))
Package: pluralize
PluralizePluralize is a Python library for Internationalization (i18n) and Pluralization.The library assumes a folder (for exaple "translations") that contains files like:it.json
it-IT.json
fr.json
fr-FR.json(etc)Each file has the following structure, for example for Italian (it.json):{"dog":{"0":"no cane","1":"un cane","2":"{n} cani","10":"tantissimi cani"}}The top level keys are the expressions to be translated and the associated value/dictionary maps a number to a translation.
Different translations correspond to different plural forms of the expression,Here is another example for the word "bed" in Czech{"bed":{"0":"no postel","1":"postel","2":"postele","5":"postelí"}}To translate and pluralize a string "dog" one simply wraps the string in the T operator as follows:>>>frompluralizeimportTranslator>>>T=Translator('translations')>>>dog=T("dog")>>>print(dog)dog>>>T.select('it')>>>print(dog)uncane>>>print(dog.format(n=0))nocane>>>print(dog.format(n=1))uncane>>>print(dog.format(n=5))5cani>>>print(dog.format(n=20))tantissimicaniThe string can contain multiple placeholders but the {n} placeholder is special because
the variable called "n" is used to determine the pluralization by best match (max dict key <= n).T(...) objects can be added together with each other and with string, like regular strings.T.select(s) can parse a string s following the HTTP accept language format.Update the translation filesFind all strings wrapped in T(...) in .py, .html, and .js files:matches=T.find_matches('path/to/app/folder')Add newly discovered entries in all supported languagesT.update_languages(matches)Add a new supported language (for example german, "de")T.languages['de']={}Make sure all languages contain the same origin expressionsknown_expressions=set()forlanguageinT.languages.values():forexpressioninlanguage:known_expressions.add(expression)T.update_languages(known_expressions))Finally save the changes:T.save('translations')
Package: pluralizer
Why this project?This repo is simply a Python port ofhttps://github.com/blakeembrey/pluralizewhich has > 1.4m github usages and 3.5 million downloads per week when I evaluating different libraries.This module uses a pre-defined list of rules, applied in order, to singularize or pluralize a given word. There are many cases where this is useful, such as any automation based on user input. For applications where the word(s) are known ahead of time, you can use a simple ternary (or function) which would be a much lighter alternative.I have compared the following alternatives and foundhttps://github.com/blakeembrey/pluralizeis the best one for me (most accurate), so ported it into the Python world.TextBlob:https://github.com/sloria/TextBlobinflect:https://github.com/jazzband/inflectNLTK Wordnet:https://www.nltk.org/howto/wordnet.htmlInstallationpipinstallpluralizerUsagefrompluralizerimportPluralizerpluralizer=Pluralizer()assertpluralizer.pluralize('apple',1,False)=='apple'assertpluralizer.pluralize('apple',1,True)=='1 apple'assertpluralizer.pluralize('apple',2,False)=='apples'assertpluralizer.pluralize('apple',2,True)=='2 apples'assertpluralizer.plural('apple')=='apples'assertpluralizer.singular('apples')=='apple'assertpluralizer.isPlural('apples')==Trueassertpluralizer.isPlural('apple')==Falseassertpluralizer.isSingular('apples')==Falseassertpluralizer.isSingular('apple')==TrueLicenseMITAll credits tohttps://github.com/blakeembrey/pluralize.
Package: pluralkit
pluralkit.pyPython wrapper forPluralKit's API.InstallingPython 3.6 or higher is required.# linux/macOSpython3-mpipinstall-Upluralkit# windowspy-3-mpipinstall-UpluralkitQuick examplesProvided a system's authorization token, the examples below print the system description and list the system's members.Async usagepluralkit.py was created withdiscord.pyin mind, and so the default implementation isasynchronous.frompluralkitimportClientimportasynciopk=Client("token")# your token hereasyncdefmain():system=awaitpk.get_system()print(system.description)members=pk.get_members()asyncformemberinmembers:print(f"{member.name}(`{member.id}`)")loop=asyncio.get_event_loop()loop.run_until_complete(main())Synchronous usageBlocking execution may be specified with the client argumentasync_mode=False.frompluralkitimportClientpk=Client("token",async_mode=False)system=pk.get_system()print(system.description)members=pk.get_members()formemberinmembers:print(f"{member.name}(`{member.id}`)")TokenThe client can be used without one'sPluralKit authorization token, but it's required for editing one's system or members or for accessing one's private system or member info.Contributors ✨Thanks to these wonderful people (emoji key) and users in the Discord who actively supported development:Alyx💻🤔🚇⚠️💬Kotocade💻📖🤔🚧📆💬Ashton Power💻📓System in a Box🐛Gem💻🐛LinksPyPI linkLatest build of the docspluralkit.py Discord support serverPluralKit support serverPluralKit's API
Package: pluralsight
pluralsight===========.. image:: https://img.shields.io/pypi/v/pluralsight.svg:target: https://pypi.python.org/pypi/pluralsight.. image:: https://img.shields.io/travis/tonybaloney/pluralsight.svg:target: https://travis-ci.org/tonybaloney/pluralsight.. image:: https://readthedocs.org/projects/pluralsight/badge/?version=latest:target: https://readthedocs.org/projects/pluralsight/?badge=latest:alt: Documentation StatusPluralsight client library for API management* Free software: Apache-2 license* Documentation: https://pluralsight.readthedocs.org.Features--------* Invitation management using the license API* User management using the license API* Team information* Invite URL generationUsage-----.. code-block:: pythonfrom pluralsight.licensing import LicensingAPIClientclient = LicensingAPIClient(plan, api_key)invites = client.invites.get_all_invites()=======History=======1.2.1 (12th July 2018)----------------------* Decode report download to remove BOM from Python 31.2.0 (5th Feb 2018)--------------------* Fixed issue with report downloads just being named the plan instead of a CSV name0.16.0 (20th Jan 2017)----------------------* Added string representations for the core models0.15.0 (19th Jan 2017)----------------------* Add support for filtering invitations0.14.0 (17th Jan 2017)----------------------* Add support for generating the invite URL from an invite object using :class:`Invite`.`generate_url()`0.13.0 (21st Dec 2016)----------------------* Add support for cancelling invitations0.12.0 (20th Dec 2016)----------------------* Fix bug in initialization of invite objects0.11.0 (20th Dec 2016)----------------------* Provide the error message from the Pluralsight API on non-20x responses0.10.0 (2016-12-12)------------------* First stable release on PyPI.* Support for models, invites, users and reports
Package: pluribus
Having just finished reading the original GoogleMapReduce paper, I
obviously felt the need to try to implement such a system in Python.My goals are to implement enough of the functionality described in the
paper to be usable, though I strongly warn against ever using this code
for anything real.Since one of the goals (see Goals, below) is simplicity from an end-user
standpoint, I am following some of Kenneth Reitz’sadviceand starting
with a readme and documentation.ExamplesThe canonical word-count example:# myjob.py
from pluribus import job


@job.map_
def emit_words(key, value):
    # key: document name
    # value: document contents
    for word in value.split():
        yield word, 1


@job.reduce_
def sum_occurences(key, values):
    # key: a word
    # values: a list of counts
    return sum(values)Assuming you’re running everything on one host, you can ignore the
network connection information.Start a pluribusmaster:$ pluribus masterStart a pluribusworker(or several hundred):$ pluribus workerOn the master or on another machine that can talk to the master:$ pluribus job myjob
# ... wait
<results>GoalsExplicit goals are:Simple to use, both as an administrator and end-user.Well-documented.Robust to worker failure.Fast-enough.Use only the Python (2.7+) standard library (at least to run).Explicit non-goals are:Be a filesystem.Robust to master failure.
Package: plurk-dice
Plurk DiceInstallpipinstallplurk-diceUsage>>>fromplurk_diceimportDice# Roll a dice directly>>>Dice(20).roll(){'result':7,'url':'https://s.plurk.com/ff94b39b3f0927042f8479fac0fd92d1.png'}>>>Dice("bzz").roll(base64=True){'result':'B','url':'https://s.plurk.com/e3481a0219283c49455d8af6012980ea.png','base64':'iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAARxJREFUeNqs1bFLAmEYx/H3Ui6c2sR0jByV3EWE2gMRkyJpcDOXBsF2JynrDwhqUf8MHaWWtKWtocBwDhzCvhePcYOHd+/bC5/hOR5+vHfv3XOWrb6V5krgEEOMlxc3lP6KoYEbpP8jMIU48riTWjswigpCUmdwiz3dwCpyrnqOJLJhjbB91Fz1APeY4CNo4A5aciCf6Mjzm/51OK+NT1voYYERDlb1+Q0L4VrC+tj16vUTZuESX7iSnSqTwDpmaMJe178u7AxvOJedKpPAE7ygEuDgPANLeEI5SJhX4BEeUQwatirQuc1nnZ0tOV/KJiIooI42urojKCyz7BinuMCDwUj7HV/veJUPvK8MlyW/AGdQbsvEmJsE/ggwAMem4bIle0IVAAAAAElFTkSuQmCC'}# Roll dices parse from text>>>Dice.parse("(dice20)(dice8)")[{'result':2,'url':'https://s.plurk.com/27866de1cbed77d98cd8a886205c9dcb.png'},{'result':6,'url':'https://s.plurk.com/17c9123ed084f917ede14447afdfabdf.png'}]>>>Dice.parse("(dice20)(dice8)",base64=True)...Support emojis(dice2)Run testspython-munittest