Saravanan666/pypi-org huggingface dataset:
Package: departure-server-led-matrix
Departure board servers (Python)This repository contains the source code for the Python Departure board servers, which can be plugged into thePython Departure module.It contains the following board server back ends:Pygame,SDL2,LED matrix, for physical departure boards powered by Raspberry Pi and the Python bindings of therpi-rgb-led-matrixproject.InstallationOn Debian-based Linux (and similarly for other flavours of Linux), for the Pygame back end, make sure the following packages are installed:$ sudo apt-get install python3-dev libsdl-image1.2-dev libsdl-mixer1.2-dev \
    libsdl-ttf2.0-dev libsdl1.2-dev libsmpeg-dev python-numpy subversion \
    libportmidi-dev ffmpeg libswscale-dev libavformat-dev libavcodec-dev \
    libfreetype6-devThe SDL2 back end is built on PySDL2: seehttps://pysdl2.readthedocs.io/en/latest/install.html#prerequisitesits prerequisites.Note– For this back end, before starting the server,make surethat thePYSDL2_DLL_PATHenvironment directory points to the SDL2 library (e.g.SDL2.dllon Windows) if it's not in the standard library directories.The Pygame and SDL2 back ends can be installed using:$ pip install departure-server-pygame
$ pip install departure-server-sdlThese commands will install the prerequired Python packages.To use the LED matrix back end on a Raspberry Pi with suitable LED matrices (e.g. 3 64x32 matrices),first install the rgbmatrix module as per the instructions, then run:$ pip install departure-server-led-matrixUsageUse thedeparture-servercommand to start a board server with a specific back end.Running the command without an argument will show the available back ends.$ departure-serverOnce the board server has been started, on the client side (e.g. using thedepartureCLI or the Departure web API server), set theDEPARTURE_BOARD_SERVERenvironment variable to the IP address or hostname of the server, then start the client.Here is an image of the board server running the Pygame back end:AboutWritten bySébastien Pujadas, released under theMIT license.
Package: departure-server-pygame
Departure board servers (Python)This repository contains the source code for the Python Departure board servers, which can be plugged into thePython Departure module.It contains the following board server back ends:Pygame,SDL2,LED matrix, for physical departure boards powered by Raspberry Pi and the Python bindings of therpi-rgb-led-matrixproject.InstallationOn Debian-based Linux (and similarly for other flavours of Linux), for the Pygame back end, make sure the following packages are installed:$ sudo apt-get install python3-dev libsdl-image1.2-dev libsdl-mixer1.2-dev \
    libsdl-ttf2.0-dev libsdl1.2-dev libsmpeg-dev python-numpy subversion \
    libportmidi-dev ffmpeg libswscale-dev libavformat-dev libavcodec-dev \
    libfreetype6-devThe SDL2 back end is built on PySDL2: seehttps://pysdl2.readthedocs.io/en/latest/install.html#prerequisitesits prerequisites.Note– For this back end, before starting the server,make surethat thePYSDL2_DLL_PATHenvironment directory points to the SDL2 library (e.g.SDL2.dllon Windows) if it's not in the standard library directories.The Pygame and SDL2 back ends can be installed using:$ pip install departure-server-pygame
$ pip install departure-server-sdlThese commands will install the prerequired Python packages.To use the LED matrix back end on a Raspberry Pi with suitable LED matrices (e.g. 3 64x32 matrices),first install the rgbmatrix module as per the instructions, then run:$ pip install departure-server-led-matrixUsageUse thedeparture-servercommand to start a board server with a specific back end.Running the command without an argument will show the available back ends.$ departure-serverOnce the board server has been started, on the client side (e.g. using thedepartureCLI or the Departure web API server), set theDEPARTURE_BOARD_SERVERenvironment variable to the IP address or hostname of the server, then start the client.Here is an image of the board server running the Pygame back end:AboutWritten bySébastien Pujadas, released under theMIT license.
Package: departure-server-sdl
Departure board servers (Python)This repository contains the source code for the Python Departure board servers, which can be plugged into thePython Departure module.It contains the following board server back ends:Pygame,SDL2,LED matrix, for physical departure boards powered by Raspberry Pi and the Python bindings of therpi-rgb-led-matrixproject.InstallationOn Debian-based Linux (and similarly for other flavours of Linux), for the Pygame back end, make sure the following packages are installed:$ sudo apt-get install python3-dev libsdl-image1.2-dev libsdl-mixer1.2-dev \
    libsdl-ttf2.0-dev libsdl1.2-dev libsmpeg-dev python-numpy subversion \
    libportmidi-dev ffmpeg libswscale-dev libavformat-dev libavcodec-dev \
    libfreetype6-devThe SDL2 back end is built on PySDL2: seehttps://pysdl2.readthedocs.io/en/latest/install.html#prerequisitesits prerequisites.Note– For this back end, before starting the server,make surethat thePYSDL2_DLL_PATHenvironment directory points to the SDL2 library (e.g.SDL2.dllon Windows) if it's not in the standard library directories.The Pygame and SDL2 back ends can be installed using:$ pip install departure-server-pygame
$ pip install departure-server-sdlThese commands will install the prerequired Python packages.To use the LED matrix back end on a Raspberry Pi with suitable LED matrices (e.g. 3 64x32 matrices),first install the rgbmatrix module as per the instructions, then run:$ pip install departure-server-led-matrixUsageUse thedeparture-servercommand to start a board server with a specific back end.Running the command without an argument will show the available back ends.$ departure-serverOnce the board server has been started, on the client side (e.g. using thedepartureCLI or the Departure web API server), set theDEPARTURE_BOARD_SERVERenvironment variable to the IP address or hostname of the server, then start the client.Here is an image of the board server running the Pygame back end:AboutWritten bySébastien Pujadas, released under theMIT license.
Package: depayco
Django integration with ePayco (epayco.co), Colombian payment gateway.Installationpip install depaycoSetdepaycoon INSTALLED_APPSSet secret and public key insettings:EPAYCO_PUBLIC_KEY: StringEPAYCO_SECRET_KEY: StringAdd plans tosettingsfile:PLANS = (
    {
        'id_plan': 'love2d_course',
        'name': 'love2d Course',
        'description': 'The most beautiful love2d course',
        'amount': 29.99,
        'currency': 'USD',
        'interval': 'month',
        'interval_count': 1,
        'trial_days': 14,
    },
    {
        'id_plan': 'defold_course',
        'name': 'defold Course',
        'description': 'The most mad defold course',
        'amount': 29.99,
        'currency': 'USD',
        'interval': 'month',
        'interval_count': 1,
        'trial_days': 14,
    }
)Note: for create plan in epayco.co run commandsync_plansCreate tables in DBpython manage.py migrateCommandspython manage.py sync_plansto create plans on epayco.copython manage.py sync_subscriptionsto keep update your subscriptions on DBConfigurationsDEBUG_EPAYCO: BooleanEPAYCO_PUBLIC_KEY: StringEPAYCO_SECRET_KEY: StringPLANS: TupleBuy me a coffee
Package: depcheck
Depcheck is a command line code-quality tool which supports adopting a layered architecture
by making it possible to specify dependency constraints between packages of your own Python application.
The tool aims to achieve the same goals asDeptracin PHP andJDependin JavaInstallViapoetry(recommended): Install withpoetry add depcheckViapip: Install fromPypiviapip install depcheckUsageTo run via CLI you run:depcheck<root_dir>-f<config_file># Or, with poetrypoetryrundepcheck<root_dir>-f<config_file>Theexampledirectory demonstrates how the tool works.cdexample

poetryrundepcheckexample-f.depcheck.ok.yml# This should be correctpoetryrundepcheckexample-f.depcheck.errors.yml# This should give errorsTo understand how to configure the tool, look inside the YML files. The-fargument is optional.
Implicitly, the tool will look for.depcheck.yml.NOTE:Package directories should contain__init__.pyto be recognized as a package!ContributingAll contributions are welcomed! See ourCONTRIBUTING.mddocument.
Package: depeche-db
Depeche DBA library for building event-based systems on top of PostgreSQLDocumentation:https://depeche-py.github.io/depeche-db/Source code:https://github.com/depeche-py/depeche-dbDepeche DB is modern Python library for building event-based systemsKey features:Message store with optimistic concurrency control & strong ordering guaranteesSubscriptions with "at least once" semanticsParallel processing of (partitioned) subscriptionsNo database pollingRequirementsPython 3.9+SQLAlchemy 1.4 or 2+PostgreSQL 12+Installationpipinstalldepeche-db# ORpoetryadddepeche-dbExampleimportpydantic,sqlalchemy,uuid,datetimeasdtfromdepeche_dbimport(MessageStore,StoredMessage,MessageHandler,SubscriptionMessage,)fromdepeche_db.toolsimportPydanticMessageSerializerDB_DSN="postgresql://depeche:depeche@localhost:4888/depeche_demo"db_engine=sqlalchemy.create_engine(DB_DSN)classMyMessage(pydantic.BaseModel):content:intmessage_id:uuid.UUID=pydantic.Field(default_factory=uuid.uuid4)sent_at:dt.datetime=pydantic.Field(default_factory=dt.datetime.utcnow)defget_message_id(self)->uuid.UUID:returnself.message_iddefget_message_time(self)->dt.datetime:returnself.sent_atmessage_store=MessageStore[MyMessage](name="example_store",engine=db_engine,serializer=PydanticMessageSerializer(MyMessage),)message_store.write(stream="aggregate-me-1",message=MyMessage(content=2))print(list(message_store.read(stream="aggregate-me-1")))# [StoredMessage(message_id=UUID('...'), stream='aggregate-me-1', version=1, message=MyMessage(content=2, message_id=UUID('...'), sent_at=datetime.datetime(...)), global_position=1)]classContentMessagePartitioner:defget_partition(self,message:StoredMessage[MyMessage])->int:returnmessage.message.content%10classMyHandlers(MessageHandler[MyMessage]):@MessageHandler.registerdefhandle_message(self,message:SubscriptionMessage[MyMessage]):print(message)aggregated_stream=message_store.aggregated_stream(name="aggregated",partitioner=ContentMessagePartitioner(),stream_wildcards=["aggregate-me-%"],)subscription=aggregated_stream.subscription(name="example_subscription",handlers=MyHandlers(),)aggregated_stream.projector.run()subscription.runner.run()# MyHandlers.handle_message prints:# SubscriptionMessage(partition=2, position=0, stored_message=StoredMessage(...))ContributeContributions in the form of issues, questions, feedback and pull requests are
welcome. Before investing a lot of time, let me know what you are up to so
we can see if your contribution fits the vision of the project.
Package: depend
dependA dependency analysis tool for various languages and package managers.Local Development / TestingCreate and activate a virtual environmentRunpip install -r requirements-dev.txtto do an editable installRunpytestto run testspytest-watch--runner='coverage run --rcfile=.coveragerc.local -m pytest --testmon'\--onfail="notify-send --urgency=low -i error 'Tests Failed'"\--onpass="coverage html --skip-covered"terminal-notifier -messageType CheckingRunmypy .Create and upload a package to PyPIMake sure to bump the version insetup.cfg.Then run the following commands:rm-rfbuilddist
pythonsetup.pysdistbdist_wheelThen upload it to PyPI usingtwine:twineuploaddist/*
Package: dependable
dependableDependency injection system extracted fromfastapiimportasynciofromrandomimportrandomfromdependableimportdependant,Depends@dependantasyncdefmain(*,choice:int=Depends(random))->None:print(choice)asyncio.run(main())More onexamplesInstallationpoetryadddependable# pip install dependablePython 3.6Backport require ofasync-exit-stackandasync_generatorpoetryaddasync-exit-stackasync_generator# pip install async-exit-stack async_generatorDevelopmentdockerbuild-tdependable.dockerrun--rm-v$(pwd):/usr/src/appdependablescripts/devReferencestiangolo/fastapi#2967LicenseThis project is licensed under the terms of the MIT license.
Package: dependably-me
dependably.meSMS reminders for the things that matter.Note: dependably.me is new and experimental. Here be dragons 🐉Introdependably.me helps you keep track of recurring and one-off events by generating and sending SMS messages, viaTwilio.
Stay on top of birthdays, renewals and chores (like watering your houseplants 🌱) with lowest-common-denominator technology; SMS.How it worksdependably.me allows you to save your reminders in YAML documents, and to express the frequency of each event using crontab expressions.
For example:# reminders.yml-id:barbossas-birthdaytitle:Captain Barbossas' Birthdaydescription:Send him the monkey.schedule:"0011*"contacts:-jack-sparrowThis reminder is for a birthday event that begins every year on the 1st of January at midnight.
The contacts who will recieve notifications arejack-sparrow.
Contacts are also managed in YAML documents:# contacts.yml-id:jack-sparrowname:Captain Jack SparrowContact phone numbers are secret, and are sourced from the capatalised snake-case form of the contactid, prefixed withDPM_.
Jacks number should be set atDPM_JACK_SPARROW, and dependably.me supports sourcing these from a.envfile at the root of the project directory.Finally, aproject.ymllaces everything together:version:1reminders_files:-reminders.ymlcontacts_files:-contacts.ymlReminders and Contacts are sourced from all of the files listed (paths relative to the project root), allowing you to organise your reminders and contacts however you choose.
For example, you might like to group by kind of reminder:version:1reminders_files:-birthdays/family.yml-birthdays/friends.yml-chores/chores.yml-cars/mot.yml-cars/tax.ymlcontacts_files:-contacts.ymlIn addition to sourcing telephone numbers from env vars, dependably.me also requires Twilio configuration via env vars too.
The following are required for dependably.me to send SMS messages:DPM_TWILIO_ACCOUNT_SID=<twilio account sid>
DPM_TWILIO_AUTH_TOKEN=<twilio auth token>
DPM_TWILIO_MESSAGING_SERVICE_SID=<twilio messaging service sid>Setting up Twilio to send messages is easy. Check out theirProgramable SMS Python QuickstartUsageWith some reminders added and you project configured, you can send reminders using:dependably-meremindersremindTo view the messages generated without sending any messages, try:dependably-meremindersremind--dry-runScheduling messagesdependably.me is designed to be invoked weekly, to notify of events happening in that week, the rest of the month and next month.
Therefore it is recommended to run dependably.me from your preferred scheduler, such as cron locally or github actions (or similar) in the cloud.
Package: dependencies
DependenciesConstructor injection designed with OOP in mind.Documentation|Source Code|Task TrackerDependency Injection (or simply DI) is a great technique. By using it you can
organize responsibilities in you codebase. Define high level policies and system
behavior in one part. Delegate control to low level mechanisms in another part.
Simple and powerful.With help of DI you can use different parts of your system independently and
combine their behavior really easy.If you split logic and implementation into different classes, you will see how
pleasant it becomes to change your system.This tiny library helps you to connect parts of your system, in particular - to
inject low level implementation into high level behavior.ProsProvide composition instead of inheritance.Solves top-down architecture problems.Boilerplate-free object hierarchies.API entrypoints, admin panels, CLI commands are oneliners.ExampleDependency injection withoutdependencies>>>fromapp.robotimportRobot,Servo,Amplifier,Controller,Settings>>>robot=Robot(...servo=Servo(amplifier=Amplifier()),...controller=Controller(),...settings=Settings(environment="production"),...)>>>robot.work()Dependency injection withdependencies>>>fromdependenciesimportInjector>>>classContainer(Injector):...robot=Robot...servo=Servo...amplifier=Amplifier...controller=Controller...settings=Settings...environment="production">>>Container.robot.work()QuestionsIf you have any questions, feel free to create an issue in ourTask Tracker. We have thequestion labelexactly for this purpose.Enterprise supportIf you have an issue with any version of the library, you can apply for a paid
enterprise support contract. This will guarantee you that no breaking changes
will happen to you. No matter how old version you're using at the moment. All
necessary features and bug fixes will be backported in a way that serves your
needs.Please contactproofit404@gmail.comif you're
interested in it.Licensedependencieslibrary is offered under the two clause BSD license.— ⭐ —
Package: dependencies-resolver
Command line tool for downloading dependencies from a configuration file.
The configuration file must follow the schema configured inconfig/schema
.json.You can also specify the exact path to the file if that was uploaded manually and not by thes3-uploader.This is part of Onfido’s team blobs store project.The purpose of this tool is to download the project’s dependencies
configured from a configuration file. Resources can be uploaded using the
complimentary tool thes3-uploader.Installing$pipinstalldependencies-resolverHow to useExample for using the tooldependencies-resolver-cdependencies.jsonGet the projectClone the git repository$gitclonehttps://github.com/onfido/dependencies-resolverInstall a virtualenv$sudoapt-getinstallpython-virtualenvCreate a new virtualenv$virtualenvdependencies_resolver_veInstall project’s requirements$dependencies_resolver_ve/bin/pipinstall-rrequirements.txtReporting IssuesIf you have suggestions, bugs or other issues specific to this library, open
an issue, or just be awesome and make a pull request out of it.
Package: dependency-algorithm
Dependency AlgorithmHere is my take on an algorithm in Python that resolves dependencies. The best way to illustrate how this works is with an example...ExampleLet's say that we have the following dictionary where the keys are items, and the values are the dependencies of those items. Each dependency must itself be an item, and items with no dependencies have an empty list[]as they dependency:my_items={'A':['B','C','D'],# -- A is dependent on B, C, D,'B':[],# -- B is dependent on nothing, etc.'C':['D'],'D':['B','E'],'E':['F'],'F':[],'Z':['A','B','C','D']}Note that we've only provided a partial dictionary of items to their dependencies...for example, notice how C is dependent on D, which is dependent on B (no dependencies) and E, which is dependent on F...therefore, C is dependent on D, B, E, and F.We can use theDependenciesclass to get the complete list of dependencies for an item, like so:fromdependency_algorithmimportDependencies# Creating a Dependencies objectdependencies=Dependencies(my_items)dependencies.complete_dependencies("C")>>> ['D', 'B', 'E', 'F']More importantly, we can return the items in an order such that the dependencies resolve:dependencies.resolve_dependencies()>>> ['B', 'F', 'E', 'D', 'C', 'A', 'Z']In many cases, there are multiple correct ordering of our items such that each item's dependencies resolve. If we're interested in all possible correct orderings, theDependenciesclass can permutate over all possible orderings, and identify the correct ones (albeit at a high computational cost), like so:dependencies.all_possible_resolution_orders(verbose=True)>>> Number of permutations: 5040
>>> Number of correct orderings: 3
>>> Number of incorrect orderings: 5037
>>> [('B', 'F', 'E', 'D', 'C', 'A', 'Z'),
>>>  ('F', 'B', 'E', 'D', 'C', 'A', 'Z'),
>>>  ('F', 'E', 'B', 'D', 'C', 'A', 'Z')]That's pretty much it! TheDependenciesclass also performs two checks, one for any dependencies that are "missing" (i.e., they are not keys in the input dictionary of items and dependencies), and another for cirular dependencies (i.e., A is dependent on B which is dependent on A which is...and so on...).Installationpip install dependency_algorithmRunning the unit tests withpytestgit clone https://github.com/jakesherman/dependency_algorithm.git
cd dependency_algorithm
pip install -e .
python -m pytestFuture workNew version ofDependencies._enhanced_list_dependenciesthat uses iteration instead of recursionImproved version ofDependencies.all_possible_resolution_ordersthat uses a more efficient algorithm than looping through permutations, ex. a recursive algorithm
Package: dependency-checker
Dependency CheckerA lightweight pythonic way to verify if python packages are on the latest versionInstallpip install dependency-checkerHow to usefrom dependency_checker import get_installed_dependencies, is_latest_versiondependency_checkerhas two functionalities:Checking a python project's dependenciesChecking if a python package is on the latest versionEach are intuitive to use, and have detailed documentation available.To check a package's dependencies, we can use theget_installed_dependenciesfunction, passing in the string name of the module:get_installed_dependencies('dependency-checker', depth_limit=1){'packaging': '21.0', 'pip': '21.2.4', 'pipdeptree': '2.1.0'}Generally a depth of 1 is enough to get a package's main dependencies, barpip,packaging, and other "standard" python resources.If we also want to include the original package, we can pass that in as a parameter:get_installed_dependencies('dependency-checker', depth_limit=1, include_self=True){'dependency-checker': '0.0.1',
 'packaging': '21.0',
 'pip': '21.2.4',
 'pipdeptree': '2.1.0'}There also existsis_latest_version, which will see if a package version is the latest available onpypi:is_latest_version('pipdeptree', '2.0.9')FalseAutomatically Building a requirements.txt fileYou can also use dependency_checker to automatically build a requirements file from the command-line. It is an extension ofpipreqs, combining both our functionalities together to give a more fine-grained and stable text file.To read more, see the documentationhere
Package: dependency-dash
A fully Open Source dependency dashboard.TestsPyPIActivityQAOtherInstallationdependency-dashcan be installed from PyPI.To install withpip:$python-mpipinstalldependency-dashUsageBefore starting you’ll need tocreate a personal access token.
The token doesn’t need access to any additional scopes.Then set theGITHUB_TOKENenvironment variable to the token.dependency-dashsupports.envfiles is you wish to place the token in there instead.You’ll also need to set theDD_ROOT_URLto the root URL of the web server,
including the scheme.
This defaults tohttp://localhost:5000.Then run the app using aWSGI serversuch as Gunicorn:$gunicorndependency_dash:app-w4-b127.0.0.1
Package: dependency-fixer
dependencyfixerA python dependency fixer and importable script functionThis python script can work as a standalone python module installer and can be used to install modules in program runtime by importing thefixfunction from dependencyfixer into program.usespip._internal.cli.main.main()function to install#pros of using this packageStandalone installing scriptCan install many modules at oncegives report of how many script left to be installed(unsuccessful attempts)#installpip install dependency-fixer#usage❖Direct:*(If are using source clone)rundependencyfixer.pyand follow instruction❖Importing to other python scriptsImport it like:from dependencyfixer import fixFunction and Arguements:Function:fix(dep,auto=True,instantkill=False)Arguements:Mandatory:dep( List of all packages to be installed or checked )Optional:
➤instantkill( If setTruethen stops any futher execution of script in which function is used )( False by default )➤auto( If setFalsethen asks for user's consent to install packages, if user refuses, then return result=0 )( True by default )➤verbose( If setTruethen prints details in console during installation and after installation )( False by default )Example:dep=['pillow','jupyter']result,leftdep=fix(dep)This function returns 2 values :leftdependencies : (list of packages that couldn't be installed)result {1,0,-1}
| 1   | :   All modules installed
| 0   | :   No modules installed
| -1 | :   Some modules can not be installed