Saravanan666/pypi-org huggingface dataset:
Package: discoverable-garage-door
discoverable-garage-doorA python 3 module that takes advantage of Home Assistant's MQTT discovery protocol via ha-mqtt-discoverable to create a Raspberry PI GPIO garage door implementation.Table of ContentsRequirementsRaspberry PIDebianPythonInstallinginstallationUsageConfigurationFormatVersion HistoryVersion 0.1.1 - Complete build configVersion 0.1.2 - Add Lovelace UI exampeVersion 0.1.3 - Rename logger.confVersion 0.1.4 - Get test bed operatingUses ha-mqtt-discoverableRequirementsRaspberry PIdiscoverable_garage_door is designed to run on a PI Zero, Pi 3B+ or PI 4B it may run on other models.Debiandiscoverable_garage_door is designed to run on Debian Bullseye it may run on other versions.Pythondicscverable_garage_door runs on Python 3.10 or later.Installinginstallationpip install discoverable_garage_door- not yet implementedUsagepython3 -m discoverable_garage_doorConfigurationa logger configuration file (logger.conf) may be placed in the current directorya yaml-format configuration file may (.config.yaml) may be placed in the current directory or be specified by the 'config' environment variableFormatExample:mqtt_broker:host:local-broker.localusername:homeassistantpassword:passworddiscovery_prefix:homeassistantstate_prefix:hmdgpio:button_push_duration_ms:500contact_bounce_time_ms:200contact_pullup:truedoors:-button_pin:18closed_contact_pin:27name:maingaragedooropened_contact_pin:17mqtt_broker.host -the name or address of the MQTT brokermqtt_broker.username -the username to use to connect with the MQTT brokermqtt_broker.password -the password to use to connect with the MQTT brokermqtt_broker.discovery_prefix -the prefix to use to publish messages to the MQTT broker, hormally homeassistantmqtt_broer.state_prefix -the prefix to use to subscribe messages to the MQTT brokergpio.button_push_duration_ms -the length of time in milliseconds that garage door button is virtually pressed, default 500 (ms)gpio.contact_bounce_time_ms -the length of time to use to debounce the GPIO inputs, normally 200 (ms)gpio.contact_pullup -whether to use a pullup for the GPIO inputs(true) or whether a pullup will be externally used (false)gpio.doors -a list of door descriptionsdoor.name -the name of the garage doordoor.button_pin -the number of the pin used for the button (GPIO numbering)door.closed_contact_pin -the number of the pin used for the closed contact (GPIO numbering)door.opened_contact_pin -the number of the pin used for the opened contact (GPIO numbering)Version HistoryVersion 0.1.1 - Complete build configVersion 0.1.2 - Add Lovelace UI exampeVersion 0.1.3 - Rename logger.confVersion 0.1.4 - Get test bed operatingUses ha-mqtt-discoverableha-mqtt-discoverable-cli
Package: discoverhue
Discovery of hue bridges per the Philips design guide.Usediscoverhueto find the IP addresses of all hue bridges on the
LAN. If previously known bridge serial numbers are provided then the
returned info will be filtered. Alternatively, serial numbers and last
known IP addresses pairs may be provided. In this case, the provided
addresses will be checked first and the discovery methods will only be
executed if unmatched bridges remain.Currently,discoverhueimplements options one,two, and three of the
Hue Bridge Discovery Guide available with registration atMeetHue.InstallationpipinstalldiscoverhueExamplesExecute discovery and return a dictionary of all found bridges:importdiscoverhuefound=discoverhue.find_bridges()forbridgeinfound:print('    Bridge ID{br}at{ip}'.format(br=bridge,ip=found[bridge]))Execute discovery and return a filtered list of bridges:# using a list, matches will be removed from search_idsearch_id=['0017884e7dad','001788102201']found=discoverhue.find_bridges(search_id)# using a set, matches will be removed from search_idsearch_id={'0017884e7dad','001788102201'}found=discoverhue.find_bridges(search_id)# using a tuple, immutable so matches will not be removedsearch_id=('0017884e7dad','001788102201')found=discoverhue.find_bridges(search_id)Execute discovery and return single IP address as string:>>>found=discoverhue.find_bridges('001788102201')>>>found.lower()'http://192.168.0.1:80/'Validate provided IP’s and execute discovery only if necessary:>>>discoverhue.find_bridges({'0017884e7dad':'192.168.0.1','001788102201':'192.168.0.2'}){'0017884e7dad':'http://192.168.0.27:80/'}ContributionsWelcome athttps://github.com/Overboard/discoverhueStatusReleased.SSDP AttributionOriginal compliments of @dankrause athttps://gist.github.com/dankrause/6000248Python3 support from @voltagex athttps://github.com/voltagex/junkcode/blob/master/Python/dlna_downloader/ssdp.pyServer field addition and Win32 @Overboard athttps://github.com/Overboard/discoverhue/blob/master/discoverhue/ssdp.py
Package: discovery30303
Discovery 30303Discover devices that respond on port 30303InstallationInstall this via pip (or your favourite package manager):pip install discovery30303Contributors ✨Thanks goes to these wonderful people (emoji key):This project follows theall-contributorsspecification. Contributions of any kind welcome!CreditsThis package was created withCookiecutterand thebrowniebroke/cookiecutter-pypackageproject template.
Package: discovery-capability
# Project Hadron
## OverviewProject Hadronis an open-source application framework for in-memory preprocessing, where
data analysis, machine learning, and other data-intensive tasks require efficiency and speed.
With :Apache Arrow as its canonical, and a more directed use of pandas,Project Hadronoffers effective data management, extensive interoperability, improved memory
management and hardware optimization.At its concept,Project Hadronwas conceived with a desire to improve the availability of
objective relevant data, increase the transparency and traceability of data lineage and facilitate
knowledge transfer, retrieval and reuse.At its coreProject Hadronis a selection of capabilities that
represent an encapsulated set of actions that act upon a given set of features or dataset. An
example of this would be FeatureSelection, a capability class, encapsulating cleaning data by
removing uninformative columns.For the complete documentation [read-the-docs](https://discovery-capability.readthedocs.io/en/latest/)## Installation### Python version
We recommend using the latest version of Python. Project Hadron supports Python 3.8 and newer.### Package installation
The best way to install the component packages is directly from the
[Python Package Index](https://pip.pypa.io/en/stable/) using pip.The component package is discovery-capability and pip installed with:`bash pip installdiscovery-capability`if you want to upgrade your current version then using pip install upgrade with:`bash pip install-Udiscovery-capability`This will also install or update dependent third party packages. The dependencies are limited to
Python, PyArrow and related Data manipulation tooling such as Pandas, Numpy, scipy, scikit-learn
and visual packages matplotlib and seaborn, and thus have a limited footprint and non-disruptive
installation in a data processing environment.## Next Steps
For next steps [read-the-docs](https://discovery-capability.readthedocs.io/en/latest/)## License
Distributed under the MIT License. SeeLICENSE.txtfor more information or reference
[MIT](https://choosealicense.com/licenses/mit/)## 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
Package: discovery-client
discovery-clientAsync Python client forconsul.HTTP engine options available:aiohttpdefault;httpx.UsingInstall and update using pip:default clientpipinstall-Udiscovery-clienthttpx clientpipinstall-U'discovery-client[httpx]'LinksLicense:Apache LicenseCode:https://github.com/amenezes/discovery-clientIssue tracker:https://github.com/amenezes/discovery-client/issuesDocs:https://discovery-client.amenezes.net
Package: discovery-imaging-utils
discovery_imaging_utilsImaging utilities for the Discovery Program at the University of Minnesota. Utilities assist with the analysis of resting-state fMRI data (primarily through fMRIPREP), along with other miscellaneous utilities for FreeSurfer and general imaging analysis.This package is undergoing active development and should be used with caution.The package can be installed through "pip install discovery-imaging-utils", and required dependancies can be installed by going to the requirements.txt file and running "pip install -r requirements.txt"Documentation can be found at:https://discovery-imaging-utils.readthedocs.io/en/latest/
Package: discoverySimulator
Robotic simulator for PythonWhat's thisdiscoverySimulatoris a Python package allowing to simulate environments in which mobile robots evolve. This simulator is accompanied by an interface allowing to visualize and control the simulation. This package is ideal for a playful learning of python and a discovery of mobile robotics.DocumentationThe documentation associated with this python package can be foundhere.InstallationUse the package managerpipto install the packagediscoverySimulator:$pipinstalldiscoverySimulatorUsage exampleCodefromdiscoverySimulator.simulationimportSimulation,EnvironmentfromdiscoverySimulator.robotsimportRectangularTwoWheelsRobot# Create robot and assign wheel speedmyRobot=RectangularTwoWheelsRobot()myRobot.setRightWheelSpeed(500)myRobot.setLeftWheelSpeed(200)# Create environmentenvironmentWidth=1500environmentHeight=1500myEnvironment=Environment(environmentWidth,environmentHeight)myEnvironment.addObject(myRobot,200,200,90)# Create and run simulationmySimulation=Simulation(myEnvironment)mySimulation.run()mySimulation.showInterface()Code resultHelp and bug reportsGeneral questions and comments can be sent to the following email address:discoverysimulator@gmail.com.You can also report bugs at this same email address.How to contributeWe are open to contributions, so send us your ideas or code amendments to the following email address:discoverysimulator@gmail.com, and we will do our best to accommodate you!CreditsCopyright (c) 2022, Leo Planquette & Eloise Lefebvre.LicensediscoverySimulatoris released under the GPL v3 license and under a commercial license that allows for the development of proprietary applications.Additional details about this license can be foundhere.
Package: discr
discerGeneric linear-time sorting and partitioningBased onthis paperby Fritz Henglein.Warning before you start using this libraryThe standard librariessortedfunction has linear-time sorting in the average case (Timsort) and is way more optimized than this library and will almost certainly be faster than any sorting done with this library.discer.relationscontains aRelationtype that represents theOrderandEquivtypes from the paper along with a few of standard relations from the paper.discer.groupinganddiscer.sortingcontain the respectiveEquivandOrderbased from functions from the paper.Future workNot in any particular order:Better README and docsAdd some testsOptimizeLazy evaluation over the key/pair list to reduces passes on itDefer tosortedwhen it will likely (or definitely) run in linear timeThe paper includes some optimizations not includedGeneric Multiset Programmingmay also contain further optimizationsSetupSumLandProductLto useTypeVarTupleFunctions to extend Relationslist :: Relation a -> Relation [a]tuple :: Relation a -> Relation Tuple[a, ...]dict :: Relation a -> Relation Dict[k, a]Refactorsdiscanddisc, the functions are basically exactly the same except how they deal withNaturalAdd compatibility for at least Python 3.8+ReferencesHenglein, Fritz. "Generic top-down discrimination for sorting and partitioning in linear time."Journal of Functional Programming22.3 (2012): 300-374.
Package: discrete
This is a Pure Python implementation of several discrete probability
distributions. There are no external dependencies.Why would you use this over, say, numpy and scipy? The main reason would
be is if, for whatever reason, you’re unable to install C extensions
(for example, you need to work with 32-bit Python on a 64-bit system)
and just need to generate random events. The Pythonrandommodule
supports generating events for several continuous random distributions
not discrete ones, hence this module.UsageAll implemented distributions are a subclass of the abstract Discrete
class, withpdf(k),cdf(k), andgenerate(n)methods. The
generate method returns an array of sizenpopulated with randomly
distributed variables from the distribution.Currently the Poisson and Binomial distributions are implemented. More
will likely be added in the future.Legaldiscrete is released under the MIT License; see attached LICENSE file.
Package: discrete-differentiator
discrete_differentiatorTakes a series of equally spaced points, and computes the point-wise derivative.Takes a sequence of numbers, and returns a sequence of numbers
that are the derivative of the given sample.The sequence may either be a Python array, or available in a CSV
file. Differentiation is done as follows:For first data point uses:        f'(x) =(-f(x+2h) + 4*f(x+h) - 3*f(x))/(2h)
For internal data points uses:    f'(x) =(f(x+h) - f(x-h))/(2h)
For last data point uses:         f'(x) =(f(x-2h)  - 4*f(x-h) + 3*f(x))/(2h)Accommodates CSV files with or without column header. Also
accommodates CSV files with multiple columns, of which one contains
the sequence to differentiate.Despite many parameters, simple cases are simple. Examples:from discrete_differentiator.discrete_differentiator import DiscreteDifferentiator as DD

o DD.differentiate([2,4,6,7])
o Given a csv file foo.csv with a single column of numbers:
   DD.differentiate('foo.txt')
o A csv file like this:
     "trash column", 10
     "more trash", 20
   DD.differentiate('foo.txt', colIndex=1)See test file for more examples.
Package: discrete-event-simulation
[![PyPI version](https://badge.fury.io/py/discrete-event-simulation.svg)](https://pypi.org/project/discrete-event-simulation/)
# Discrete event simulationThis package can be used to create a discrete event simulation based on your parameters. Just install the library (pypi library is WIP) and use
theDiscreteSimulationclass to run with your environment.## How to apply it to your scenarioCheck out the [examples](https://github.com/AlexanderGrooff/discrete-event-simulation/tree/master/examples) where scenarios are sketched out using this framework.
The idea is that you state one or more available actions that the simulation can pick from which have a starting condition and events to trigger.The events that are triggered by actions will modify the state, which is tracked in the simulation’sTimeline.## DevelopmentMake a virtualenv, install requirements and runtoxto ensure everything works. It works from Python 3.8+.` mkvirtualenv-a.-ppython3 $(basename $(pwd)) pip install-rrequirements.txt tox `
Package: discrete-fuzzy-operators
FuzzyDiscreteOperators is a library to operate with discrete fuzzyoperators (discrete aggregation functions, discrete t-norms, discretet-conorms, discrete copulas, discrete uninorms, etc). Each family ofoperators mentioned above has in turn different subfamilies; in thislibrary, they are also implemented as SN-implications, R-operators,quasi-copulas, t-subnorms, etc.Since these operators are useful in other applied fields, the librarycontains thedecision_makingmodule, with emphasis on discrete fuzzynumbers, two tuples and ordinal Yager decision functions. They are alsovery useful in mathematical morphology. For more information, see`Discrete FuzzyMorphologyhttps://github.com/mmunar97/discrete_fuzzy_morphology`__.DocumentationAll documentation can be found on `thispagehttps://app.gitbook.com/@mmunar97/s/discrete-fuzzy-operators/`__.
Package: discrete-math-helper
1. IntroductionSimple calculator for solving problems related to discrete mathmatics, such as combinations, probabilities, truth-tables, and more.2. How to Installpip install discrete-math-helperpip install --upgrade discrete-math-helper3. How to Runfrom discrete_math_helper import calccalc = calc.Calculator()#Combination Example: calc.combination(6, 2)#Truth Table Example: calc.truthtable("p and q")4. Available ArgumentsCombinations: calc.combination(n,r)Permutations: calc.permutation(n,r)Truth Table: calc.truthtable("statement containing variables: p, q")Bayes' Probability: calc.bayes(P(T|A), P(A), P(T))Big O Calculator: calc.bigo(a,b,d)5. Creater Contact InformationEmail:dokkuh@umich.eduPhone: (479) 544-28856. ContributorsZalan Shah:zalans@umich.edu
Package: discrete-optimization
Discrete OptimizationDiscrete Optimization is a python library to ease the definition and re-use of discrete optimization problems and solvers.
It has been initially developed in the frame ofscikit-decidefor scheduling.
The code base starting to be big, the repository has now been splitted in two separate ones.The library contains a range of existing solvers already implemented such as:greedy methodslocal search (Hill Climber, Simulated Annealing)metaheuristics (Genetic Algorithms, NSGA)linear programmingconstraint programminghybrid methods (LNS)The library also contains implementation of several classic discrete optimization problems:Travelling Salesman Problem (TSP)Knapsack Problem (KP)Vehicle Routing Problem (VRP)Facility Location Problem (FLP)Resource Constrained Project Scheduling Problem (RCPSP). Several variants of RCPSP are availableGraph Colouring Problem (GCP)In addition, the library contains functionalities to enable robust optimization
through different scenario handling mechanisms) and multi-objective optimization
(aggregation of objectives, Pareto optimization, MO post-processing).InstallationQuick version:pipinstalldiscrete-optimizationFor more details, see theonline documentation.DocumentationThe latest documentation is availableonline.ExamplesSome educational notebooks are available innotebooks/folder.
Links to launch them online withbinderare provided in theNotebooks sectionof the online documentation.More examples can be found as Python scripts in theexamples/folder, using the different features of
the library and showing how to instantiate different problem instances and solvers.ContributingSee more about how to contribute in theonline documentation.LicenseThis software is under the MIT License that can be found in theLICENSEfile at the root of the repository.Some minzinc models have been adapted from files coming fromhttps://github.com/MiniZinc/minizinc-benchmarksunder the samelicense,https://github.com/youngkd/MSPSP-InstLibfor which we have the written authorization of the author.
Package: discrete-probabilistic-model
Discrete Probabilistic ModelA simple probabilistic modeling framework with discrete variables.Free software: MIT licenseDocumentation:https://discrete-probabilistic-model.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2022-12-20)First release on PyPI.
Package: discrete-signals
A domain specific language for modeling and manipulating discrete
    time signals.AboutThis library aims to provide a domain specific language for modeling
and manipulating discrete time signals. Intuitively, most of the time,
the discrete time signal's value is undefined.Ifdiscrete-signalsisn't for you, I recommend checking outtraces(which this
library took design inspiration from). Both libraries offer a
convenient way to model unevenly-spaced discrete time signals.Installation$ pip install discrete-signalsUsagefromdiscrete_signalsimportsignalx=signal([(0,1),(1,2),(2,3)],start=0,end=10,tag='x')y=signal([(0.5,'a'),(1,'b'),(2,'c')],start=0,end=3,tag='y')x# start, end: [0, 10)# data: [(0, {'x': 1}), (1, {'x': 2}), (2, {'x': 3})]y# start, end: [0, 3)# data: [(0.5, {'y': 'a'}), (1, {'y': 'b'}), (2, {'y': 'c'})]Parallel Compositionx|y# start, end: [0, 10)# data: [(0, {'x': 1}), (0.5, {'y': 'a'}), (1, {'x': 2, 'y': 'b'}), (2, {'x': 3, 'y': 'c'})]Concatenationx@y# start, end: [0, 13)# data: [(0, {'x': 1}), (1, {'x': 2}), (2, {'x': 3}), (10.5, {'y': 'a'}), (11, {'y': 'b'}), (12, {'y': 'c'})]Retagging/Relabelingx.retag({'x':'z'})# start, end: [0, 10)# data: [(0, {'z': 1}), (1, {'z': 2}), (2, {'z': 3})]Time shiftingx>>1.1# start, end: [1.1, 11.1)# data: [(1.1, {'x': 1}), (2.1, {'x': 2}), (3.1, {'x': 3})]x<<1# start, end: [-1, 9)# data: [(-1, {'x': 1}), (0, {'x': 2}), (1, {'x': 3})]Slicingx[1:]# start, end: [1, 10)# data: [(1, {'x': 2}), (2, {'x': 3})]x[:1]# start, end: [0, 1)# data: [(0, {'x': 1})]Rolling Windowx.rolling(1,3)# start, end: [-1, 7)# data: [(-1, {'x': (1, 2)}), (0, {'x': (2, 3)}), (1, {'x': (3,)})]Mapping a FunctionOne perform a point wise transform of the signal. For example, the
following is equivalent to retagging the signal and adding 1.x.transform(lambdaval:{'y':val['x']+1})# start, end: [0, 10)# data: [(0, {'y': 2}), (1, {'y': 3}), (2, {'y': 4})]Alternatively,DiscreteSignals support mapping the dictionary of values to a single value (and optionally tag it):x.map(lambdaval:str(val['x']),tag='z')# start, end: [0, 10)# data: [(0, {'z': '1'}), (1, {'z': '2'}), (2, {'z': '3'})]Filter a signalx.filter(lambdaval:val['x']>2)# start, end: [0, 10)# data: [(2, {'x': 3})]Projecting onto a subset of the tags.(x|y).project({'x'})# start, end: [0, 10)# data: [(0, {'x': 1}), (1, {'x': 2}), (2, {'x': 3})]Attributes(x|y).tags# {'x', 'y'}x.values()# SortedDict_values([defaultdict(None, {'x': 1}), defaultdict(None, {'x': 2}), defaultdict(None, {'x': 3})])list(x.times())# [0, 1, 2]