Saravanan666/pypi-org huggingface dataset:
Package: metrology
A library to easily measure what’s going on in your python.Metrology allows you to add instruments to your python code and hook them to external reporting tools like Graphite so as to better understand what’s going on in your running python program.InstallingTo install :pip install metrologyAPIGaugeA gauge is an instantaneous measurement of a valueclassJobGauge(metrology.instruments.Gauge):defvalue(self):returnlen(queue)gauge=Metrology.gauge('pending-jobs',JobGauge())CountersA counter is like a gauge, but you can increment or decrement its valuecounter=Metrology.counter('pending-jobs')counter.increment()counter.decrement()counter.countMetersA meter measures the rate of events over time (e.g., “requests per second”).
In addition to the mean rate, you can also track 1, 5 and 15 minutes moving averagesmeter=Metrology.meter('requests')meter.mark()meter.countor as a decorator:@Metrology.meter('requests')defdo_this_again():# do somethingor with context manager:withMetrology.meter('requests'):# do somethingTimersA timer measures both the rate that a particular piece of code is called and the distribution of its durationtimer=Metrology.timer('responses')withtimer:do_something()or as a decorator:@Metrology.timer('responses')defresponse():# do_somethingUtilization TimerA specialized timer that calculates the percentage of wall-clock time that was spentutimer=Metrology.utilization_timer('responses')withutimer:do_something()Tagging metricsAll metrics can be tagged if the reporter supports it (currently: Graphite, Librato, Logger. The StatsD reporter supports the Datadog tag format because no official tag standard has been devised by the project).
Tags can be arbitrary key-value pairs. Just assign a dict as metric name. A ‘name’-entry is required.counter=Metrology.counter({'name':'pending-jobs','host':'backend','priority':'high'})counter.increment()counter.decrement()counter.countAll metric types support tagging.ReportersLogger ReporterA logging reporter that write metrics to a loggerreporter=LoggerReporter(level=logging.INFO,interval=10)reporter.start()Graphite ReporterA graphite reporter that send metrics to graphitereporter=GraphiteReporter('graphite.local',2003)reporter.start()Librato ReporterA librator metric reporter that send metrics to librato APIreporter=LibratoReporter("<email>","<token>")reporter.start()Ganglia ReporterA ganglia reporter that sends metrics to gmond.reporter=GangliaReporter("Group Name","localhost",8649,"udp",interval=60)reporter.start()StatsD ReporterA statsd reporter that sends metrics to statsd daemon.reporter=StatsDReporter('localhost',3333,conn_type='tcp')reporter.start()or use default UDP setting:reporter=StatsDReporter('localhost',3333)reporter.start()AcknowledgementThis is heavily inspired by the awesomemetricslibrary.
Package: metroloj
MetroloJ-for-pythonMetroloJ is an ImageJ software plugin that helps keeping track of microscopes' performances by extracting 4 relevant estimators out of standardized images, acquired from test samples[1].The present project aims to implement MetroloJ functionalities on python.metroloj package'metroloj' is a pip package that provides functions to analyze microscope images.requirementsin a virtual envirenement, run the following command:python -m pip install -r metroloj/requirements.txtReferences[1]https://imagejdocu.tudor.lu/plugin/analysis/metroloj/start
Package: metrolopy
MetroloPytools for dealing with physical quantities:  uncertainty propagation and unit conversionMetroloPy is a pure python package and requires Python 3.5 or later and the SciPy stack (NumPy, SciPy and Pandas).  It looks best in a Jupyter Notebook.Install MetroloPy withpip install metrolopyorconda install -c conda-forge metrolopy.Physical quantities can then be represented in Python asgummyobjects with an uncertainty and (or) a unit:>>> import metrolopy as uc
>>> a = uc.gummy(1.2345,u=0.0234,unit='cm')
>>> a
1.234(23) cm

>>> b = uc.gummy(3.034,u=0.174,unit='mm')
>>> f = uc.gummy(uc.UniformDist(center=0.9345,half_width=0.096),unit='N')
>>> p = f/(a*b)
>>> p
2.50(21) N/cm2>>> p.unit = 'kPa'
>>> p.uunit = '%'
>>> p
25.0 kPa ± 8.5%MetroloPy can do much more including Monte-Carlo uncertainty propagation, generating uncertainty budget tables, and curve fitting.  It can also handle expanded uncertainties, degrees of freedom, correlated quantities, and complex valued quantities. See:a tutorial(ordownload the tutorial as Jupyter notebook)the documentationthe issues page on GitHuba list of the units built into MetroloPya list of the physical constants built into MetroloPynew in version 0.6.0A constant library has been added with physical constants that can be accessed
by name or alias with theconstantfunction.  Thesearch_constantsfunction
with no argument gives a listing of all built-in constants.  Each constant
definition includes any correlations with other constants.TheQuantityclass has been added to represent a general numerical value
multiplied by a unit and theunitfunction has been added to retrieveUnitinstances from the unit library by name or alias.Unitinstances
can now be multiplied and divided by otherUnitinstances to produce
composite units, can be multiplied and divided by numbers to produceQuantityinstances or multiply or divideQuantityinstances.  Thegummyclass is now a subclass ofQuantitywith anummyvalue rather
than a subclass ofnummy.  AQuantityArrayclass has been introduced
to represent an array of values all with the same unit.  Multiplying aUnitinstance by a list, tuple, or numpy array produces aQuantityArrayinstance.Theimmyclass has been introduced as anummyvalued counterpart of thejummyclass for representing complex values with uncertainties.immyandjummyvalues can now be displayed in a polar representation in addition
to a cartesian representation.immyandjummy.r and .phi properties
have been added to access the magnitude and argument of the values as a
complement to the .real and .imag properties.
Package: metromobilite
MetromobiliteA Python client for interacting withMetromobilite API(Transport for Grenoble, TAG).Installationpipinstallmetromobilitegitclonegit@github.com:PierreBerger/metromobilite.gitcdmetromobilite
pythonsetup.pyinstallUsageImport and initialization:frommetromobiliteimportMetromobilitem=Metromobilite(origin='My Origin')print(m.get_stoptimes('SEM:2216'))All stops and routes are vailable here :https://data.metromobilite.fr/api/routers/default/index/routesSeeMetromobilite API documentationfor more informations.
Package: metron
PinaxPinax is an open-source platform built on the Django Web Framework. It is an ecosystem of reusable Django apps, themes, and starter project templates.
This collection can be found athttp://pinaxproject.com.This app was developed as part of the Pinax ecosystem but is just a Django app and can be used independently of other Pinax apps.metronmetronprovides analytics and metrics integration for Django.Current analytics services supported:Google AnalyticsMixpanelgaug.esGoogle AdWords Conversion TrackingDocumentationThemetrondocumentation can be found online athttp://metron.readthedocs.org/.
The Pinax documentation is available athttp://pinaxproject.com/pinax/. If you would like to help us improve our documentation or write more documentation, please join our Pinax Project Slack channel and let us know!Code of ConductIn order to foster a kind, inclusive, and harassment-free community, the Pinax Project has a code of conduct, which can be found herehttp://pinaxproject.com/pinax/code_of_conduct/.Pinax Project Blog and TwitterFor updates and news regarding the Pinax Project, please follow us on Twitter at @pinaxproject and check out our bloghttp://blog.pinaxproject.com.
Package: metronetpy
metronetpyPython Package for programmatically controlling Security and Intrusion systems made by IESS (http://iessonline.com). Metronet is the cloud application provided by IESS that allows authenticated user to manage their own IESS security system. This was originally designed formetroneta custom_component forHome Assistant.NOTE:Metronet has no official API; therefore, this library may stop
working at any time without warning.CreditsOriginally inspired byconcord232andpythonegardiaAdditional scaffolding fromalexapyContributingCheck for open features/bugsorinitiate a discussion on one.Fork the repository.Install the dev environment:make init.Enter the virtual environment:pipenv shellInstall requirements:pip3 install -r requirements.txtCode your new feature or bug fix.Write a test that covers your new functionality.UpdateREADME.mdwith any new documentation.Run tests and ensure 100% code coverage for your contribution:make coverageEnsure you have no linting errors:make lintAdd yourself toAUTHORS.md.Submit a pull request!LicenseGPLv30. By providing a contribution, you agree the contribution is licensed under GPLv3.
Package: metronome-loop
metronome-loopLibrary for easy timing withouttime.sleep()Example useimportmetronome_loopdeffive_sec_prin():print("five_sec")one_sec=metronome_loop.metronome(1000,lambda:print("one_sec"))five_sec=metronome_loop.metronome(5000,five_sec_prin)ten_sec=metronome_loop.metronome(10000)whileTrue:one_sec.loop()five_sec.loop()iften_sec.loop():print("ten_sec")
Package: metronomiconic
Metronome which does all you’d expect from a metronome, and has a unique
double/half tempo feature! An iconic metronome.Installationpip install metronomiconicIt requires python3+ to run.Do you know Victor Wooten?In one of his videos on working with metronome, this incredible musician
showed an exercise to build one’s rhythm feel: you play a groove/a
phrase to a comfortable click tempo, say 120 bpm. Then, when you feel
you’re in the pocket, you drop the tempo 2 times, but play the same. You
just end up with less clicks to hear. When you’re confident you’ve
caught the pulse, you drop it once again. In the end, you’re playing the
same fast groove in 120 bpm, supported by only 1 click per 2 or even 4
bars. Isn’t that an incredible exercise?But here’s the problem: when practicing, you need to stop and adjust
your metronome tempo carefully for a few seconds, effectively losing the
pocket and feel. Withmetronomiconicit only takes one keypress.Please read further.UsageInstall it.Create a directory under your home directory called.metronomiconic.
Place there two or three sound files (bar.wav,beat.wav,division.wavwhich can be omitted, and if it is, you will be unable
to hear subdivision notes).A collection of default click sounds from popular DAWs can be foundhere.
The reason I do not include them in distribution in simple: they are not
free, and the free ones I’ve heard… well I don’t like them.You’re ready to go. Typemetronomicin your favorite terminal
emulator.Press space bar to stop or start. Use arrow keys and arrow keys with
shift to change tempo. Use digits, alt+up and alt+down to change time
signature (1 to 9 for beat count and 1,2,4,8,16 for beat length are
supported). Tempo is measured with quarter notes.Press p to stop/start play subdivisions. Press t, q or s to switch
triplet, quintuplet or septuplet subdivision mode starting with the next
bar (normally, every beat is subdivisioned in sixteenth notes).And now for the most cool part: doubling and halfing the tempo.Press u or d to double or half the tempo from the next bar.NotesI’m a learning bass player, and I couldn’t get why I can’t find a
metronome that would do this half/double thing for me, so I had to come
up with my own. The ‘learning functions’, as I call them, that include
half/double and tri-, quintu- and septuplet modes work from the next bar
played. All the other changes take place immediately.I’ve tested metronome’s accuracy for a little while, but so far I can
say it’s pretty accurate, compared with a few hardware, DAW and online
metronomes.Do not look in the code! It’s very messy and unmaintainable, and there
is at least one very dirty hack.Released under MIT license.
Package: metro-notation
metro-notationVisualize the Rubik's cube algorithms in a notation like a train route map that I call"Metro notation (メトロ記法)"."Metro notation"focuses on the direction in which the force of each finger is applied.Installationpip3installmetro-notationorpipinstallmetro-notationUsagemetro-notation[filename]Algorithm notation format#ignores up to the end of the line as a comment[name]specifies the name of the following algorithm@+ROBGWYrobgwydescribes the arrangement of the cube facesRMLUDFBw2xy'describes the algorithmwhitespacesplits the algorithm into triggers----splits the following algorithms into separate columns#
# PLL algorithms
#

[Ua Perm]
@GGGRoRBrBObOwwwwwwwww
RU'RU RU RU'R'U' R2

[Z Perm]
@GrGRgRBoBObOwwwwwwwww
M2'U'M2'U' M'U2' M2'U2'M'

----

[Ra Perm]
@OwwwwwwRRBwBwwwwwwwww
RU'R'U' RURD R'U'RD' R'U2R'

[Gb Perm]
@OwOwwwBBwwwwwwwwwwwww
F'U'F R2UwR'U RU'RUw' R2'OutputsStandard algorithms in Metro notation (pdf,pptx)PLL AlgorithmsOLL Algorithms
Package: metron-tagger
Quick DescriptionA command-line tool to tag comic archives with metadata frommetron.cloud.InstallationPyPiOr install it yourself:$pipinstall--usermetron-taggerFAQHow to enable RAR support?It depends on the unrar command-line utility, and expects it to be in your $PATH.Helpusage: metron-tagger [-h] [-r] [-o] [--id ID] [-d] [--ignore-existing] [-i] [--missing] [-s] [-z] [--validate] [--delete-original] [--duplicates] [--version] path [path ...]

Read in a file or set of files, and return the result.

positional arguments:
  path                 Path of a file or a folder of files.

options:
  -h, --help           show this help message and exit
  -r, --rename         Rename comic archive from the files metadata. (default: False)
  -o, --online         Search online and attempt to identify comic archive. (default: False)
  --id ID              Identify file for tagging with the Metron Issue Id. (default: None)
  -d, --delete         Delete the metadata tags from the file. (default: False)
  --ignore-existing    Ignore files that have existing metadata tag. (default: False)
  -i, --interactive    Interactively query the user when there are matches for an online search. (default: False)
  --missing            List files without metadata. (default: False)
  -s, --sort           Sort files that contain metadata tags. (default: False)
  -z, --export-to-cbz  Export a CBR (rar) archive to a CBZ (zip) archive. (default: False)
  --validate           Verify that comic archive has a valid ComicInfo.xml. (default: False)
  --delete-original    Delete the original archive after successful export to another format. (default: False)
  --duplicates         Identify and give the option to delete duplicate pages in a directory of comics. (Experimental) (default: False)
  --version            Show the version number and exitBugs/RequestsPlease use theGitHub issue trackerto submit bugs or request features.LicenseThis project is licensed under theGPLv3 License.
Package: metropolis
Metropolis (Python Microservice Gateway with NATS)Can we makesimple,scalable,observable,operableservice gateway?PurposeCloud NativeSingle Workload UnitService DiscoveryService MeshArchitecture Concept+- Cluster --------------------------------------------------+
  |                                                            |
  |  +- Node-1 --+  +- Node-2 -+  +- Node-3 --+  +- Node-4 -+  |
  |  |           |  |          |  |           |  |          |  |
  |  | Worker-a  |  |          |  |           |  | Worker-d |  |
  |  | Worker-b  |  | Worker-c |  | Worker-a  |  | Worker-c |  |
  |  |    |      |  |    |     |  |    |      |  |    |     |  |
<======= NATS ========= NATS ======================= NATS =======>
  |  |    |      |  |          |  |    |      |  |          |  |
  |  |  Gateway  |  |          |  |  Gateway  |  |          |  |
  |  |    |      |  |          |  |    |      |  |          |  |
  |  +--- | -----+  +----------+  +--- | -----+  +----------+  |
  |       |                            |                       |
  |       +--------------+-------------+                       |
  |                      |                                     |
  |                   Ingress                                  |
  +--------------------- | ------------------------------------+
                         VComponentsNatsMessage busWorkerBusiness Logic workerGatewayService gatewayExampleInstall metropolis$pipinstallmetropolisDefine Worker taskfrommetropolisimportWorkerworker=Worker(nats='nats://localhost:4222')@worker.task(subject='foo.bar',queue='worker')defmytask(data,*args,**kwargs):"""Simple task which returns reverse string"""returndata[0][::-1]worker.run()Define GatewayfrommetropolisimportGatewayimportsettingsgateway=Gateway(nats='nats://nats:4222')gateway.app.run(host='0.0.0.0')
Package: metropro-dat-reader
Metropro dat readerRequirementsPython 3.10 or higherhttps://www.python.org/downloads/InstallFrom the command line:pip install metropro-dat-readerUsagempdr <path to dat file>examples:mpdr C:\Users\user\Downloads\abc123.datmpdr def456.datExample output❮ mpdr SN9_PLANO_SR_UC37.dat
SN9_PLANO_SR_UC37.dat
magic_number: 2283471727
header_format: 1
header_size: 834
swinfo.type: 0
swinfo.date:
swinfo.vers.maj: 8
swinfo.vers.min: 0
swinfo.vers.bug: 0
...Development setupTODO
Package: metropy
metropyMetronome with a minimal UI, written in Python 3 + ncurses.Features:Change BPMChange Beats Per BarStart/Stop metronomeCustomizable sounds (via --bar and --beat)BPM detectorInstallpipinstallmetropyUsageusage: metropy [-h] [--bar BAR_SOUND] [--beat BEAT_SOUND] [bpm] [beats]

Metronome with Terminal UI in ncurses.

positional arguments:
  bpm                BPM (default is 60)
  beats              Beats per bar (default is 4)

optional arguments:
  -h, --help         show this help message and exit
  --bar BAR_SOUND    Path of the bar sound (.wav)
  --beat BEAT_SOUND  Path of the beat sound (.wav)Examplemetropymetropy--bar/path/to/bar/sound.wav--beat/path/to/beat/sound.wavSometimes ALSA reports problem but the metronome will work anyway.As always, you can suppress the errors with:metropy 2> /dev/nullWhat it looks like
Package: metrosaopaulo
MetroSaoPauloAuthor: Julio BlancoOriginal work by: Renato Lipi, Ale Borba and Bu KinoshitaVersion: 0.0.1DescriptionCode to get a simple dictionary with lines and statues from the Official web of "Metro de São Paulo".Originally written for a home assistant sensorCreditsRenato Lipi and Ale Borba for the first python implementation that I see and Bu Kinoshita for the actual way of getting the data from the siteYou can reach the original developments inhttps://github.com/renatolipi/status_metro_spandhttps://github.com/bukinoshita/metrosp-statusLicenseCopyright 2019  Julio Manuel Blanco PérezPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: metsrw
METS Reader & WriterByArtefactualMETSRW is a library to help with parsing and creating METS files.
It provides an API, and abstracts away the actual creation of the XML.
METSRW was initially created for use inArchivematicaand is managed as part of that project.You are free to copy, modify, and distribute metsrw with attribution under the
terms of the AGPL license. See theLICENSEfile for details.Installation & DependenciesMETSRW can be installed with pip.pip install metsrwMETSRW has been tested with:Python 3.6Python 3.7Python 3.8Python 3.9Basic UsageRead a METS filemets = metsrw.METSDocument.fromfile('path/to/file')  # Reads a file
mets = metsrw.METSDocument.fromstring('<mets document>')  # Parses a string
mets = metsrw.METSDocument.fromtree(lxml.ElementTree)  # Parses an lxml.Element or lxml.ElementTreeCreate a new METS filemets = metsrw.METSDocument()ContributingMETSRW is in early development and welcomes feedback on the API and overall design!
Design goals, use cases, and a proposed API are in theGithub wiki
Package: mettle
Mettle is a framework for managing extract/transform/load (ETL) jobs.  ETL
processes present a number of problems that Mettle is designed to solve:DescriptionJobs need to be run at specific times.  Sometimes they need to be triggered by
the completion of other jobs.   Mettle supports scheduling both time-based
and trigger-based jobs.Various people in an organization need to be able to see job schedules and
the state of recent runs.  Naive scripts running on cron jobs, scattered
amongst a large number of servers, create a serious problem with visibility.
Mettle solves this by centralizing the job scheduling, state reporting, and
log viewing.Sometimes jobs fail because of temporary problems somewhere (a flaky network,
a too-full disk).  Mettle will automatically retry jobs to deal with this.Sometimes jobs fail and will not be able to succeed until the job has been
reconfigured (a changed password on a database, for example).  Mettle makes it
easy to manually re-launch a job after such issues have been resolved.If you try to solve the above problems by centralizing all your ETL execution,
you quickly run into a problem of proliferating dependencies.  A centralized
ETL service can become hard to develop and hard to deploy because all those
dependencies (libraries, external APIs, external databases) introduce more
instability.  Mettle is designed to isolate those dependencies into separate
ETL services, so instability in one ETL doesn’t impact any others.We picked the name “Mettle” because:It’s got the letters E, T, and L in it.It means “ability to continue despite difficulties”.It sounds like “metal”, which is solid.Mettle is comprised of several components:Web UI.  Features:Configure schedules for pipelines.Display past jobs, both successful and failed.Display currently-executing jobs, with live status updates and streaming
logs.Manually launch jobs.Timer: Reads pipeline schedules from the database and sends out RabbitMQ messages
when pipelines need to be kicked off.Dispatcher: Records which jobs are being executed by which workers, and their
eventual success or failure.Logger: Receives log messages sent from ETL Services over RabbitMQ, and saves
them to Postgres.ETL Services: Implement the actual business logic and systems integration to
move data between systems.Mettle uses Postgres to store state, and RabbitMQ for inter-process
communication.