Saravanan666/pypi-org huggingface dataset:
Package: plucogen
PluCoGen CoreIntroductionPluCoGen, or Pluggable universal Code Generator, is conceived to be a modular program which reads data from datafiles (YAML, JSON,...) or databases and generates generic code with the help of templates (e.g. Jinja2).While YAML, JSON and Jinja2 are part of the core (for now), PluCoGen offers the possibility to add new formats by plugin modules.Current StateThe project is currently in a very early stage and experiences rapid development. Until version 1.0.0 is reached, breaking of the API might occure at any time.VersioningPluCoGen uses semantic versioning according to the SemVer specification.Contributing to DevelopmentMerge requests are welcome! Clone the repository an preferably use the devcontainer environment or the included Dockerfile to setup a development environment.
Package: plueprint
# plueprint[API Blueprint](https://github.com/apiaryio/api-blueprint) parser written in Python.It uses [Markdown](https://pythonhosted.org/Markdown) well-known package to doinitial DOM parsing.### Installing```pip install plueprint```### UsingAs a library:```Pythonfrom markdown import Markdownm = Markdown(extensions=["plueprint"])m.set_output_format("apiblueprint")api = m.convert("""FORMAT: 1A# The Simplest APIThis is one of the simplest APIs written in the **API Blueprint**.# /message## GET+ Response 200 (text/plain)Hello World!""")print(api)```As a script:```python -m plueprint "Real World API.md"python -m plueprint "Real World API.md" -o "api.pickle"```### NotesTo suppress warnings about parsed documents, set `plueprint.entities.report_warnings` to `False`.Released under New BSD license.
Package: pl-uf-thesis
pl-uf-thesisOverviewUniversity of Florida Thesis/Dissertation Template for PyexlatexGetting StartedInstallpl-uf-thesis:pip install pl-uf-thesisA simple example:importplufthesis# Do something with plufthesisLinksSee thedocumentation here.AuthorCreated by Nick DeRobertis. MIT License.
Package: plug
PlugPlug is a tool to automate packaging and installation of Python daemons
including Python dependencies in the package. It grew out of my use of
Supervisor and the problems of managing large numbers of processe.InstallingUse pip!pip install plugCreating a PlugTo create a plug you create a config file with minimal information then runplug create {package_name}The config file looks something like:[server1]
command=bin/python -m SimpleHTTPServer 8001
user=plug_userYou will be left with a plug:{package_name}.server1.plugInstalling a PlugOnce you put this on your system you can runplug install {package_name}.server1.plugThis will create a new virtualenv in /srv/plug ready to be setup as a daemon.
To have runit start the process you run:plug setup {package_name}.server1.plugOptionally with the argument –number to setup multiple daemons from that
package. The number causes multiple links to be created in /etc/sv and
/etc/srv.Uninstalling a PlugTo uninstall the plug use theuninstallcommandplug uninstall {package_name}.server1.plugThis will also remove the links for runit.Other CommandsOther commands included arelistandstatuswhich will list all plugs
installed and the runit status of each daemon instance.
Package: plugable
Plugable: A Python Plugin FrameworkBadges:Build:Coverage:This package exposes a framework for writing extensible applications.Specifically, it allows consumers to mark an abstract class as "Plugable", using standard inheritance semantics and ABC decorators:fromabcimportabstractmethodfromplugableimportPlugableclassAbstractInterface(Plugable):@abstractmethoddefexample(self):passFollowing this, you can create subclasses for differing implementations, and register them with theAbstractInterfaceregistry, like so:classExampleOne(AbstractInterface,register="one"):# Integrated registrationdefexample(self):print("You ran ExampleOne!")classExampleTwo(AbstractInterface):defexample(self):print("You ran ExampleTwo!")AbstractInterface.registry.register("two",ExampleTwo)# Explicit registrationFinally, you can access and consume the registered implementations, like so:AbstractInterface.get("one").example()# You ran ExampleOne!AbstractInterface.get("two").example()# You ran ExampleTwo!
Package: plugable-btaps
DescriptionThis project is a library and command-line interface for communicating with and programming aPlugable PS-BTAPS1 Bluetooth Home Automation Switch.libbtaps.pyServes as a Python implementation of the BTAPS protocol, either to be used directly in your programs, or to be used as a reference in developing your own implementation in a different language.btaps.pyA simple command-line UI that implements all the features exposed by libbtaps.py.USAGE:   python btaps.py [Bluetooth address]
EXAMPLE: python btaps.py 00:00:FF:FF:00:00Implemented FunctionalityThe following functions of the Plugable PS-BTAPS1 are currently present in the library:Setting Switch On/OffReading current status of switch(name, on/off, timer settings)Creating, modifying and deleting timersChanging the device’s nameUpdating the device’s date and time to your PC’s current date and timeTO DOThe following features and items are still to come:NFControl (Device proximity on/off functionality)Security PINBetter error handlingBetter documentationMac OS X supportOS SupportDue to PyBluez limitations, this library will currently only work on Linux and Windows systems.DependenciesPython 2.7.xPyBluezInstallationFirst, install PyBluez using the appropriate link or command for your OS:WindowsDownload and installPyBluez for Python 2.7Ubuntu/Debian:sudo apt-get install python-bluezFedora:sudo yum install pybluezArch:sudo pacman -S python2-pybluezThen, simply pip install our module::pip install plugable-btapslibbtaps Docs and ExamplesFind some usage examples and documentation for libbtaps inDOCUMENTATION.rstTroubleshootingWhen I try to pip install plugable-btaps I get a compilation error:This means that you have not installed PyBluez and pip is trying to compile PyBluez from source, but you don’t have the necessary compilation dependencies installed on your system.
Install PyBluez as outlined above.
Package: plugandpie
plugandpiewas designed to automatically set up sensors with drivers, making the initial
hardware configuration simpler and faster to implement. It is powered by community contributed
drivers and it’s flexible enough to work with devices not yet directly supported. The package
also aims to provide utilities for monitoring and analyzing sensors, so you can make software-level
polling and set up complex observation models.Driver ExamplesBy specifying directly the hardware interface and address, you have an unified access method for
any register on the device.accelerometer=GenericDriver(interface=SMBusAdapter(1),address=0x1D)accelerometer.registers[0x2A].set(8)# inactiveaccelerometer.registers[0x0E].set(0)# range = 2gaccelerometer.registers[0x2A].set(9)# active, 800HzBy reading a device configuration file that reflects its datasheet, you can have better namings
for your registers.# TODOBy instantiating the correct driver, a standardized API can provide the meaningful data easily.accelerometer=MMA8452Q(interface=SMBusAdapter(1),address=0x1D)accelerometer.get_ms2()By reading a device configuration file, you can initialize all drivers immediately.# TODOCheck out the documentation for examples of basic and advanced usages.Monitor ExamplesThe most common uses of sensors is history analysis and real time telemetry. Both should
seamlessly plug intoplugandpiedrivers, so the package includes some utilities for
this purpose.Installation:plugandpierequiresSMBus, which at this time has no good Python 3 implementation or bindings.
A workaround can be found athttps://procrastinative.ninja/2014/07/21/smbus-for-python34-on-raspberry/Also,SMBusrequires repeated starts in thei2cdriver. This is not enabled by default on Raspberry Pi
and can be fixed with:echo -n 1 > /sys/module/i2c_bcm2708/parameters/combinedThis configuration resets on boot, so make sure to put this in a startup script.setup.shis a script that contain a fix for both problems, but does so in an intrusive way.
It is recommended for inexperienced users to installplugandpiefor the first time,
but experienced users should solve those problems individually.
Package: plugbear
PlugBearPython SDKConnect a custom LLM to PlugBear through a web server.FastAPIInstallationTo install the PlugBear Python SDK, run the following command:pipinstall'plugbear[fastapi]'UsageHere's a simple example to get you started:importcontextlibimportplugbear.fastapifromfastapiimportFastAPIPLUGBEAR_API_KEY=""PLUGBEAR_ENDPOINT="/plugbear"@contextlib.asynccontextmanagerasyncdeflifespan(app:FastAPI):awaitplugbear.fastapi.register(app,llm_func=some_llm,api_key=PLUGBEAR_API_KEY,endpoint=PLUGBEAR_ENDPOINT,)yieldapp=FastAPI(lifespan=lifespan)asyncdefsome_llm(context:plugbear.fastapi.Request)->str:# template prompt using `context` to your own LLM# and return resultresult:str=...returnresultFor versions below 0.93.0importplugbear.fastapifromfastapiimportFastAPIapp=FastAPI()PLUGBEAR_API_KEY=""PLUGBEAR_ENDPOINT="/plugbear"@app.on_event("startup")asyncdef_startup():awaitplugbear.fastapi.register(app,llm_func=some_llm,api_key=PLUGBEAR_API_KEY,endpoint=PLUGBEAR_ENDPOINT,)asyncdefsome_llm(context:plugbear.fastapi.Request)->str:# template prompt using `context` to your own LLM# and return resultresult:str=...returnresultOther Web server frameworksAlthough it does not yet provide an interface as convenient as FastAPI, it can be directly linked to PlugBear.InstallationpipinstallplugbearUsageTaking Django as an example, it looks like this:settings.pyimportplugbearfromasgiref.syncimportasync_to_syncPLUGBEAR_API_KEY=""PLUGBEAR_ENDPOINT="/plugbear"pb=async_to_sync(plugbear.PlugBear.init(api_key=PLUGBEAR_API_KEY))urls.pyfromdjango.confimportsettingsfromdjango.urlsimportpathfrom.importviewsurlpatterns=[path(settings.PLUGBEAR_ENDPOINT,views.handle_plugbear,name="plugbear"),]views.pyimportplugbearfromdaciteimportfrom_dictfromdjango.httpimportHttpResponsedefhandle_plugbear(request):context=from_dict(data_class=plugbear.Request,data=request.data)result=some_llm(context)returnHttpResponse(result)defsome_llm(context:plugbear.Request)->str:# template prompt using `context` to your own LLM# and return resultresult:str=...returnresult
Package: plug-email-chase
WARNING: STILL IN DEVELOPMENTplug-email-chaseA Plug Python pipeline for chase emails (transactions, balance, etc)UseThis library depends on python3. We recommend using avirtualenvlike this:python3-mvenv~/.virtualenvs/plug-email-chaseNext, install this library:source~/.virtualenvs/plug-email-chase/bin/activate
gitclonehttp://github.com/lollococce/plug-email-chasecdplug-email-chase
makeinstallOr:source~/.virtualenvs/plug-email-chase/bin/activate
pipinstallplug-email-chase
Package: plugemin
plugemin is a simple utility which uses the amazing jinja2 templating engine
and structured data such as XML, JSON or CSV to plug values into templates
many times. Think of a form letter, but endlessly useful. With this you
can render plain text, HTML, XML, JSON or even Python or C. Anything is
possible as long as it is plain text (UTF is supported) in the end.plugemin was initially designed to template commands which were to be sent over
SSH to target systems.Getting StartedThese instructions will get you a copy of the project up and running
on your local machine for development and testing purposes.PrerequisitesYou will need the following software installed:Python >= 2.7jinja2lxmllxml is the only one which needs a compiler to install. If this is an issue,
I would recomend the greatAnaconda Python Distributionwhich includes all the prerequisites installed by default.InstallingYou can install the latest stable version with the following command:$pipinstallplugeminor for the latest development version, you can use the following command:$pipinstallgit+https://github.com/ilovetux/plugemin.gitRunning the testsIn order to run the tests, you will need to clone the repository and kick off
the tests with a single command. All of that can be done with the following
commands:$gitclonehttps://github.com/ilovetux/plugemin$cdplugemin$pythonsetup.pynosetestsThat’s it, the tests should pass, if they don’t please open anissueand be sure to include:The commands you ran to get your resultsThe versions of Python, lxml and jinja2 you have installedWhat Operating systemAny details which would cause your setup to be considered non-standard
such as running an obscure version of LinuxBasic UsagePlugemin will look for templates in a series of locations and take a
structured data format as input. It will render the template with each
piece of data.Examplein C:\plugemin\templates\backup-delete.j2:cp {{src}} {{dst}}
rm {{src}}in C:\tmp\files.csv:src,dst
/var/log/*,/tmp/.
/usr/var/log/*,/tmp/.
/var/www/*,/tmp/.Then you can use the following command:C:\> plugemin -t backup-delete.j2 -d C:\plugemin\files.csv
cp /var/log/* /tmp/.
rm /var/log/*
cp /usr/var/log/* /tmp/.
rm /usr/var/log/*
cp /var/www/* /tmp/.
rm /var/www/*ContributingPlease readCONTRIBUTING.rstfor details on our code of conduct, and the process for submitting pull
requests to us.VersioningWe useSemVerfor versioning. For the versions
available, see thetags on this repository.AuthorsiLoveTuxSee also the list ofcontributorswho participated in this project.LicenseThis project is licensed under the GPL Version 3 or later, please see
theLICENSEfile for detailsAcknowledgmentsHat tip to anyone who’s code was used (Jinja2, lxml and Python)Brian Kearney and James Brennan for the inspiration to build this utilityAnyone listed in the contributors fileEveryone who helps us by submitting issues and pull requests
Package: pluggable-app-engine
pluggable_app_enginepluggable_app_engine is very simple example of plugin system for Python app.The main basis of pluggable_app_engine is treating plugins as modules. To add new plugin, just place your module or package in yourmodulesdirectory  and add its name tomodulespath in config file (config.jsonby default).The entry point of your module (or package) isinitialize_module()function. It takes only 1 argument: theAppContextobject.AppContextrepresents all data in your application. It lets you to have access to application configuration (and customize your plugins behavior without modifying plugin code) and application state.There are sample plugins inexamples/modulesdirectory. Launch theexample.pyscript to check how it works.pluggable_app_engine was tested for Python 3.5.3
Package: pluggage
PluggageA Utility library for using plugins with python
There are two ways to use this library to dynamically load objects,
a lightweight load-on-demand via a dictionary interface and a heavier
factory pattern using a base class to register objects with a factory.Lightweight PluginsThe lightweight plugin system uses a dictionary API to load dot-delimited names
and either return the object or optionally call it.frompluggage.pluginsimportPluginsloader=Plugins()# load references to objectsfunc_ref=loader['some_module.some_submodule.some_function']cls_ref=loader['some_module.some_submodule.SomeClass']# call the objects and get the resultsfunc_result=loader('some_module.some_submodule.some_function',*func_args,**func_kwargs)someclass_instance=loader('some_module.some_submodule.SomeClass',*ctor_args,**ctor_kwargs)Heavyweight PluginsThe Heavyweight Plugins are implemented via a metaclass registry that allows classes
to be registered as plugins on import, and then accessed via a named factory.
Classes inheriting from the base plugin class specify which factory they will be registered with
and by default will register under that factory with their class name, or that can also be overridden by inheritance.
The plugins can be accessed using a get_factory call provided in the pluggage.registry module.factory=get_factory('my_factory')some_class_instance=factory('SomeClass',*ctor_args,**ctor_kwargs)To register a class with a factory, inherit from the PluggagePlugin class and set the PLUGGAGE_FACTORY_NAME class attribute:frompluggage.factory_pluginimportPluggagePluginclassSomeClass(PluggagePlugin):"""
    sample plugin
    """PLUGGAGE_FACTORY_NAME='my_factory'def__init__(self,value):self.value=valuedef__call__(self):print(value)factory=get_factory('my_factory')some_class_instance=factory('SomeClass','abc')some_class_instance()# prints 'abc'
Package: pluggdapps
Pluggdapps is acomponent systemin python that can’t get any
simpler. A meta framework providing a platform to define interfaces and
implement plugins. It comes with a configuration system, web-framework,scaffold, command-line script and much more …Pluggdapps web framework, when used withtayra template language, provide a
plugin system that cut across MVC design pattern.Web-apps can be developed,
packaged and distributed as plugins. To use the web framework supplied with
pluggdapps you will have to install the latest version oftayraandtayrakitegg packages.Pluggdapps core-modules are stable, though other parts like web framework,
scaffolding are under development - you can hack the code, contribute back withgithub.Featuressimple plugin system based on interface specification.a platform to develop, package and distribute interfaces and plugins.extend the platform to populate additional context for plugin objects.an awesome configuration system.configuration can be done with one or more .ini files.browser based configuration that can be persisted in a backend store.pluggable backend store for web-based configuration. Uses sqlite3 as default
backend.command line script for administration / testing,sub-command to list matching views for application(s).sub-command to execute unit test-cases.sub-command to start web-server.implement new sub-commands, outside pluggdapps package, as plugins.define framework by specifying interfaces. Implement them as pluggable
components.web application framework.web framework, when used with tayra template language, provide a plugin
system that cut across MVC design pattern.framework is define by a set of interface specification and implemented as
pluggable components.configure the framework or even replace parts of it.host hundreds of web-application in the same environment by configuring
mount-points similar to apache virtual-hosts.application can generate urls for other hosted applications.native web server using epoll.automatic server-restart when project files are modified, useful in
development mode.package and distribute plugins as.eggfiles.documentation. Every aspect of pluggdapps is adequately documented. Although
it might be a little difficult for beginners, it is fairly accessible for
those who are comfortable with python and web-development.License:GPLv3 license.Requires:Linux, Python-3.x.Status:Core design stable. Not expected to change.Related linkspackage documentation.changelog.todo.mailing-list.To hack the guts of pluggdapps check-out the source code fromgithubor fromgoogle-code. Note that the orginal
repository is maintained with mercurial and uses hg-git plugin to publish it
on github.
Package: pluggen
PluggenA simple plugin system for python modules, allowing you to register plugins
using class decorators. This project used to be called pyplug, but someone else
obviously beat me to the name.This project came about as a part of mytoy mDNS librarythat needed a handy
way of registering DNS record types.UsageCreate a plugin collection by extending pluggen.Plugin:from pluggen import Plugin

class TestCollection(Plugin):
	paths = [ 'path.to.my.plugins' ]Then in path.to.my.plugins, create modules for your plugins and decorate them
with@TestCollection.registeror the more verbose@TestCollection.register(name="alt_name", ...).Additional parameters can be set in the register method to store metadata about
this particular plugin. The special parameternamecan be used to give the
plugin a particular name, if none is provided the class name will be used.Thenameshould be unique, duplicate names will be ignored.By default theinstance(name, config)method can then be used to instantiate
a plugin based on its name, but you are of course free to override it and/or
add any custom lookup method you wish to use.See pydoc pluggen.Plugin for more information (or read the source, it's small)
Package: plugget
Plugget: Plugin Package ManagerInstall app packages (plugins, addons, ...) with a single Python command usingPlugget.Or 1-click install plugins in Blender, Maya, Max, Substance, ...  withPlugget Qtimportpluggetplugget.install("my_package")also check out🔹Plugget QtPlugget Qt Unreal pluginPlugget Qt Blender addon(more features)Plugget Blender addon(simple)🔹plugget manifest repoplugget-qt-maya-pluginA Maya plugin that launches the Plugget Qt UI windowrequirementspip installedgit installed
(aim to auto handle requirements in future)not to confuse withPluGethThe extensible Geth fork, ethereum, golangpluGETA package manager to update minecraft server plugin & softwarepackage manager comparisonPyPi installs only packaged python modules.
Plugget supports other languages, e.g. Maxscript, and links to unpackaged repos.WinGet, chocolatey, etc. install apps, Plugget installs plugins for apps.manifest repopackage manifests live in themanifest repoissuesIf the install fails. It likely is a bad manifest, a bad install, or a bug with Plugget.
Report the issue in issues.
There's a small chance the GitHub servers are down, you can check thegithub status.communityPipelinehttps://discourse.techart.online/t/plugget-package-manager-for-tech-artists/16301Blenderhttps://blenderartists.org/t/free-plugget-a-search-engine-installer-for-add-ons/1456558Mayahttps://forums.cgsociety.org/t/plugget-a-free-maya-tool-manager/2074249TODO Polycounthttps://polycount.com/categories/technical-talkIf this tool is helpfull, you can ⭐ star it on the github page, just click the ⭐ star button in the top-right of this page.
Package: plugget-qt
Plugget QtPlugget Qt is a UI forplugget.Easily search, list & (un)installplugget packages.Plugget qt is used by:Plugget Qt Blender addonPlugget Qt Unreal pluginInstructionsTo show the qt window:importplugget_qtw=plugget_qt.show()# store reference in w, to prevent garbage collectionDark ui is not included, just add a qt stylesheet, e.g.blender-qt-stylesheetInstallation(depending on the app, you might want to replace python for the app's python interpreter, and maybe also use--target "install/path/to/folder" --no-userto install your python package to a custom folder)python -m pip install plugget-qtDependenciespluggetPython module.qtpyQt wrapper for PySide & PyQtIf this tool is helpfull, you can ⭐ star it on the github page,
just click the ⭐ star button in the top-right of this page.
Package: pluggy
This is the core framework used by thepytest,tox, anddevpiprojects.Pleaseread the docsto learn more!A definitive exampleimportpluggyhookspec=pluggy.HookspecMarker("myproject")hookimpl=pluggy.HookimplMarker("myproject")classMySpec:"""A hook specification namespace."""@hookspecdefmyhook(self,arg1,arg2):"""My special little hook that you can customize."""classPlugin_1:"""A hook implementation namespace."""@hookimpldefmyhook(self,arg1,arg2):print("inside Plugin_1.myhook()")returnarg1+arg2classPlugin_2:"""A 2nd hook implementation namespace."""@hookimpldefmyhook(self,arg1,arg2):print("inside Plugin_2.myhook()")returnarg1-arg2# create a manager and add the specpm=pluggy.PluginManager("myproject")pm.add_hookspecs(MySpec)# register pluginspm.register(Plugin_1())pm.register(Plugin_2())# call our ``myhook`` hookresults=pm.hook.myhook(arg1=1,arg2=2)print(results)Running this directly gets us:$ python docs/examples/toy-example.py
inside Plugin_2.myhook()
inside Plugin_1.myhook()
[-1, 3]
Package: pluginbase
PluginBase is a module for Python that enables the development of flexible plugin systems in Python.Step 1:frompluginbaseimportPluginBaseplugin_base=PluginBase(package='yourapplication.plugins')Step 2:plugin_source=plugin_base.make_plugin_source(searchpath=['./path/to/plugins','./path/to/more/plugins'])Step 3:withplugin_source:fromyourapplication.pluginsimportmy_pluginmy_plugin.do_something_cool()Or alternatively:my_plugin=plugin_source.load_plugin('my_plugin')my_plugin.do_something_cool()