Saravanan666/pypi-org huggingface dataset:
Package: python-ms
Python-msA Python equivalent to the JavaScriptmspackage.This port of the original project supports some additional string-to-ms
conversions, but otherwise the functionality is identical. This version
also uses integers for everything to avoid rounding errors with
floating-point numbers when using large values.Using the project's unit tests as examples is recommended, as they cover
everything.TypeBadgesPyPITestsActivityQAOtherInstallationThe project is available via PyPI:pipinstallpython_msExamplesConvert from stringsimportpython_msasmsms('2 days')# 172_800_000ms('1d')# 86_400_000ms('10h')# 36_000_000ms('2.5 hrs')# 9_000_000ms('2h')# 7_200_000ms('1m')# 60_000ms('5s')# 5_000ms('1y')# 31_557_600_000ms('100')# 100ms('-3 days')# -259_200_000ms('-1h')# -3_600_000ms('-200')# -200Convert from millisecondsimportpython_msasmsms(60_000)# "1m"ms(2*60_000)# "2m"ms(-3*60_000)# "-3m"ms(ms('10 hours'))# "10h"Time format written outimportpython_msasmsms(60_000,long=True)# "1 minute"ms(2*60_000,long=True)# "2 minutes"ms(-3*60_000,long=True)# "-3 minutes"ms(ms('10 hours'),long=True)# "10 hours"FeaturesHas no dependencies aside from the standard libraryIf a number is supplied topython_ms, a string with a unit is returnedIf a string that contains the number is supplied, it returns it as a number (e.g.: it returns100for'100')If you pass a string with a number and a valid unit, the number of equivalent milliseconds is returnedRelated Packagesms- The original JavaScriptmspackageCaught a Bug?Forkthis repository to your own GitHub account and thencloneit to your local deviceInstallpoetry(if it isn't already installed)Runpoetry installin the project directory. This fetches development dependencies likepytestand sets up everything for you to start debuggingAs always, you can run the tests using:poetry run pytest
Package: python-msp430-tools
The python-msp430-tools are a collection of tools related to the MSP430
embedded processor.Python2.6 or newer (2.x series) is required for most modules. The python
package “msp430” can be installed with “python setup.py install”. These modules
can be used as standalone applications or as library for other programs.DocumentationFor API documentation, usage andexamplessee files in the “doc”
directory.  The “.rst” files can be read in any text editor or being converted
to HTML or PDF usingSphinx. A HTML version is online athttps://python-msp430-tools.readthedocs.ioDownload toolsCommand line tools, e.g.python-mmsp430.gdb.target. They can up and
download memory of MSP430 targets.msp430.jtag.targetJTAG interfacemsp430.bsl.targetF1x, F2x, F4x BSLmsp430.bsl5.uartF5x, F6x BSL (non-USB devices)msp430.bsl5.hidF5x, F6x BSL (USB devices)msp430.gdb.targetUsing a GDB proxy (TCP/IP connection).Other toolsmsp430.memory.convertConvert between hex file formatsmsp430.memory.dcoMeasure or calibrate the DCO clockmsp430.memory.compareCompare two hex filesmsp430.memory.hexdumpShow contents of hex filesmsp430.memory.generateCreate hex files with a defined pattern. Can be
used for testing or to create underlays for other binaries (e.g. to fill
unused memory with “NOPs” or “JMP $”)msp430.memory.downloaderSmall program, suitable for file associations,
so that double clicking an ELF or a43 file can be used to download via
JTAG.msp430.asm.as,msp430.asm.ld,msp430.asm.cpp: An assembler,
linker and preprocessor for MSP430(X)msp430.asm.disassembleDescription of Python librarymsp430Root package for the Python modules related to the MSP430.msp430.asmA simple assembler and linker, also a disassembler, supporting MSP430(X).msp430.bslSupport for the boot strap loader.msp430.bsl.targetis the main
package for the downloader and contains subclassed modules for target
specific BSL hardware.msp430.bsl5Support for the boot strap loader of F5xx/F6xx devices.msp430.bsl5.hidis the main module for the downloader for F5xx USB devices andmsp430.bsl5.uartfor all others.msp430.jtagJTAG tools using the MSP430[mspgcc] library.msp430.jtag.targetis the
main module for the downloader.msp430.gdbCommunicate with a GDB server/proxy.msp430.gdb.targetis the
main module for the downloader.msp430.memoryMemory implementation, used to store an memory image used to download to
the MSP430. File format handlers are here too.
Interesting submodules are:
- convert
- compare
- hexdump
- generatemsp430.shell.commandsShell commands, useful for makefiles etc.msp430.shell.watchWatch a file for changes and execute a command in that case.msp430.listingParser for listing files.msp430.legacySupport code for older tools.
Package: python-msspeak
Author:Arezqui Belaid and Joshua PattenDescription:Microsoft Translator API module for PythonDocumentation:RTDhttps://python-msspeak.readthedocs.orgContributors:https://github.com/newfies-dialer/python-msspeak/graphs/contributorsLicense:MITMicrosoft Speech Bing Documentation:https://www.microsoft.com/cognitive-services/en-us/speech-api/documentation/API-Reference-REST/BingVoiceOutputPython Bing Speechpython-msspeak is a library to synthesize text into human sounding speech
usingMicrosoft Cognitive Services.In order to utilize this service you must sign up for Microsoft Cognitive
service and register an application. More information on creating a Microsoft
account is located at thegetting started with Text to Speechpage.QuickstartA quick-and-dirty script to utilize the python-msspeak library.from msspeak import msspeak

subscription_key = 'XXXXXXXXXXXX'

tts_msspeak = msspeak.MSSpeak(subscription_key, '/tmp/')
output_filename = tts_msspeak.speak("This is the text I will speak to you", "en-US")

print ("Recorded TTS to %s" % output_filename)InstallationInstall, upgrade and uninstall python-msspeak.py with these commands:$ pip install python-msspeak
$ pip install --upgrade python-msspeak
$ pip uninstall python-msspeakExample usage and outputUsage:$ python-msspeak --subscription_key=<subscription_key> -t <text> [-d <directory>] [-url <service_url>] [-h]Example:$ msspeak --subscription_key=XXXXXXXXX -t "Salut, Vous vous appelez comment?" -l frOutput :$ Recorded TTS to /tmp/MSTRANSLATE-8895934760117809679-fr.mp3FeedbackFeedback are more than welcome, post bugs and feature requests on github:http://github.com/newfies-dialer/python-msspeak/issuesExtra informationNewfies-Dialer, an open source Auto Dialer software, uses this module to
synthetize audio files being play to the end-user.
Further information about Newfies-Dialer can be found athttps://www.newfies-dialer.orgThis module is built and supported by Star2Billing:https://www.star2billing.comSource downloadThe source code is currently available on github. Fork away!https://github.com/newfies-dialer/python-msspeakOther librariesJavascript:https://github.com/nanek/mstranslatorPython:https://pypi.python.org/pypi/mstranslatorPython:https://github.com/bebound/Python-Microsoft-Translate-APITODO[ ] Rename package to python-bing-speechHistory0.2.1 (2017-03-03)Support Python 30.2.0 (2017-02-21)Support switch to Azure portal1.1.4 (2017-01-20)fix request deps don’t force single version0.1.1 (2015-10-08)Improve Readme and add script to updateversion0.1.0 (2015-10-06)First release on PyPI.
Package: python-mt-st
A magnetic tape drive controller ✨🍰✨A Python module for controlling magnetic tape drives under Linux from Python. The module can control
magnetic tape drive operation, just like mt variants (mt-st, mt-gnu, etc.) under Unix-like OSs.
User can do control operations and erase the cartridge. This implementation is based on
mt-gnu. In the next version we will move to communicate with linux st driver via ioctl instead.Usage[TODO]PrerequisitesCurrent version is wrapping mt-gnu. Make sure mt-gnu is in your execution path.root privilege needed by magnetic tape drive operationsPython 3Install$ cd [project_home]$ pip install .TestingYou need either a real tape drive or usemhvtlas a simulate tape drive.After tape drive is ready, update tape drive information intest/tape_conf.pyrun test cases by$ nosetests tests
Package: python-mu
Python module and CLI to package and upload python lambda functions to
AWS LambdaInstallationpip install python-muConfigurationYou will need to have a boto profile created. This can be done usingawscli:pip install awscli
aws configureUsageusage: mu [-h] [--with-pyc] [--zip-file ZIP_FILE] [--profile PROFILE]
          [--zip-only]
          [config]

positional arguments:
  config               JSON file describing this lambda function. Default
                       lambda.json

optional arguments:
  -h, --help           show this help message and exit
  --with-pyc           Package pyc/pyo files
  --zip-file ZIP_FILE  Name to give ZIP file. Default lambda.zip
  --profile PROFILE    boto/awscli profile name. Default default
  --zip-only           Only create the ZIP file, do not uploadlambda.json{
    "name": "helloworld",
    "description": "Hello, World!",
    "region": "us-east-1",
    "role": "arn:aws:iam::000000000000:role/lambda_basic_execution",
    "handler": "helloworld.lambda_handler",
    "memory_size": 128,
    "timeout": 3,
    "py_modules": [
        "helloworld"
    ],
    "packages": {
        "exclude": [
            "tests",
            "tests.*"
        ]
    },
    "deps": [
        "requests",
        "-rrequirements.txt"
    ],
    "publish": true
}
Package: python-multem
python-multemPython wrapper for MULTEMInstallationTo install from the github repository do the followingexportCUDACXX=${PATH_TO_CUDA}/bin/nvcc
python-mpipinstallgit+https://github.com/rosalindfranklininstitute/python-multem.git@masterTo install from source, clone this repository. The repository has a submodule
for pybind11 so after cloning the repository rungitsubmoduleupdate--init--recursiveThen do the following:exportCUDACXX=${PATH_TO_CUDA}/bin/nvcc
python-mpipinstall.If you would like to run the tests then, clone this repository and then do the following:exportCUDACXX=${PATH_TO_CUDA}/bin/nvcc
python-mpipinstall.[test]Installation for developersTo install for development, clone this repository and then do the following:exportCUDACXX=${PATH_TO_CUDA}/bin/nvcc
python-mpipinstall-e.TestingTo run the tests, follow the installation instructions and execute the following:pytestIssuesPlease use theGitHub issue trackerto submit bugs or request features.LicenseCopyright Diamond Light Source, 2019.Distributed under the terms of the GPLv3 license, python-multem is free and open source software.
Package: python-multibar
Project: python-multibarLicense: Apache 2.0About: Tool for static progress bars writing.OS: IndependentPython: 3.9+Typing: TypedTopic: UtilitiesDocumentation·Report Bug·Request FeatureTable of ContentsWelcome to Python-MultibarInstallationQuickstartDocumentationExamplesContributingAcknowledgmentsWelcome to Python-Multibar!Installation# Unix/macOS users should use$python-mpipinstall-Upython-multibar# Windows users should use$py-mpipinstall-Upython-multibarQuickstart>>>importmultibar>>>writer=multibar.ProgressbarWriter()>>>progressbar=writer.write(10,100)# Using __str__() method, we get a progressbar# with a basic signature.Out:'+-----'# Writer returns progressbar object.>>>type(progressbar)Out:<class'multibar.impl.progressbars.Progressbar'>DocumentationYou can access the documentation by clicking on the following link:animatea.github.io/python-multibarExamplesSome more of the features of python-multibar are in the project examples.Python-Multibar ExamplesContributingContributions 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 RequestNOTE:before creating a pull request, you first need to install the project's dependencies:pip3 install -r dev-requirements.txt -r requirements.txtThen go to the root directory of the project...\python-multibar>and start all nox pipelines using thenoxcommand.If all sessions are completed successfully, then feel free to create a pull request. Thanks for your PR's!AcknowledgmentsChoose an Open Source LicenseImg ShieldsGitHub PagesPythonPython CommunityMkDocsMkDocs Material
Package: python-multimapwithttl
MultiMapWithTTLAn implementation of multimap with per-item expiration backed up by Redis.Documentation:https://loggi.github.io/python-multimapwithttlGitHub:https://github.com/loggi/python-multimapwithttlPyPI:https://pypi.org/project/python-multimapwithttl/Free software: MITDescriptionThis lib is based on:https://quickleft.com/blog/how-to-create-and-expire-list-items-in-redis/without the need for an extra job to delete old items.Values are internally stored on Redis using Sorted Sets :key1: { (score1, value1), (score2, value2), ... }
key2: { (score3, value3), (score4, value4), ... }
...Where thescoreis the timestamp when the value was added.
We use the timestamp to filter expired values and when an insertion happens,
we opportunistically garbage collect expired values.The key itself is set to expire through redis ttl mechanism together with the newest value.
These operations result in a simulated multimap with item expiration.You can use to keep track of values associated to keys,
when the value has a notion of expiration.>>> s = MultiMapWithTTL(redis_client, 'multimap')
>>> s.add('a', 1, 2, 3)
>>> sorted(s.get('a'))
[1, 2, 3]
>>> s.add_many([('b', (4, 5, 6)), ('c', (7, 8, 9)), ])
>>> sorted(sorted(values) for values in s.get_many('a', 'b', 'c')))
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Package: python-multiplayer
Python MultiplayerFramework for Client Server Structure in Python.
Is intended to be used for multiplayer games in pygame with this Module.pygame-multiplayerPlanned featuresCommand based NetworkThreaded NetworkAsync NetworkInstallationpipinstallpython-multiplayerUsage (Command Server/Client)Server:frompy_mpimportCommandServerfrompy_mpimportServerSideServerCommandfrompy_mp.commandsimportNetworkFlagserver=CommandServer("localhost",5000)server.accept()# Receive a Command from the Clientcom=server.recv(server.clients[0])print(com)# Send a Test Command back to the Clientserver.send(ServerSideServerCommand(NetworkFlag.CONNECTED,server.clients[0],test="test"),server.clients[0])Client:frompy_mpimportCommandClientfrompy_mpimportClientCommandfrompy_mp.commandsimportNetworkFlagclient=CommandClient("localhost",5000)# Send a Test Command to the Serverclient.send(ClientCommand(NetworkFlag.CONNECTED,test="test"))# Receive a Command from the Servercom=client.recv()print(com)
Package: python-multitasking
MultiTasking: Non-blocking Python methods using decoratorsMultiTaskingis a tiny Python library lets you convert your Python methods into asynchronous,
non-blocking methods simply by using a decorator.Example# example.pyimportmultitaskingimporttimeimportrandomimportsignal# kill all tasks on ctrl-csignal.signal(signal.SIGINT,multitasking.killall)# or, wait for task to finish on ctrl-c:# signal.signal(signal.SIGINT, multitasking.wait_for_tasks)@multitasking.task# <== this is all it takes :-)defhello(count):sleep=random.randint(1,10)/2print("Hello%s(sleeping for%ss)"%(count,sleep))time.sleep(sleep)print("Goodbye%s(after for%ss)"%(count,sleep))if__name__=="__main__":foriinrange(0,10):hello(i+1)The output would look something like this:$pythonexample.pyHello1(sleepingfor0.5s)Hello2(sleepingfor1.0s)Hello3(sleepingfor5.0s)Hello4(sleepingfor0.5s)Hello5(sleepingfor2.5s)Hello6(sleepingfor3.0s)Hello7(sleepingfor0.5s)Hello8(sleepingfor4.0s)Hello9(sleepingfor3.0s)Hello10(sleepingfor1.0s)Goodbye1(afterfor0.5s)Goodbye4(afterfor0.5s)Goodbye7(afterfor0.5s)Goodbye2(afterfor1.0s)Goodbye10(afterfor1.0s)Goodbye5(afterfor2.5s)Goodbye6(afterfor3.0s)Goodbye9(afterfor3.0s)Goodbye8(afterfor4.0s)Goodbye3(afterfor5.0s)SettingsThe default maximum threads is equal to the # of CPU Cores.This is just a rule of thumb!TheThreadmodule isn’t actually using more than one core at a time.You can change the default maximum number of threads using:importmultitaskingmultitasking.set_max_threads(10)…or, if you want to set the maximum number of threads based on the number of CPU Cores, you can:importmultitaskingmultitasking.set_max_threads(multitasking.config["CPU_CORES"]*5)For applications that doesn’t require access to shared resources,
you can setMultiTaskingto usemultiprocessing.Process()instead of thethreading.Thread(), thus avoiding some of theGIL constraints.importmultitaskingmultitasking.set_engine("process")# "process" or "thread"InstallationInstall multitasking usingpip:$pipinstallmultitasking--upgrade--no-cache-dirInstall multitasking usingconda:$condainstall-cranaroussimultitaskingLegal Stuffyfinanceis distributed under theApache Software License. See theLICENSE.txtfile in the release for details.P.S.Please drop me an note with any feedback you have.Ran Aroussi
Package: python-multithreading
multithreadingA python module for creating multithreading processes easily, in a more Pythonic way.Installationpip install python-multithreadingexampleimporttimefrommultithreadingimportCaller,multi_threaded_calldefslow_function(number:int,delay:float)->dict[str,int|float]:foriinrange(number):time.sleep(delay)returndict(number=number,delay=delay)CALLS=50DELAY=0.01NUMBER=100callers=[Caller(target=slow_function,kwargs=dict(delay=DELAY,number=NUMBER))for_inrange(CALLS)]s=time.time()multi_threaded_call(callers)e=time.time()print("multi-threading: ",e-s)s=eall(slow_function(*caller.args,**caller.kwargs)forcallerincallers)e=time.time()print("single-threading: ",e-s)outputmulti-threading: 1.0473840236663818
single-threading: 52.53497314453125
Package: python-mumps
Python-MUMPSPython bindings for theMUMPS: a parallel sparse direct solver.ScopeThis package targets MUMPS packaged by conda-forge using Cython bindings. It
aims to provide a full wrapper of the MUMPS sequential API. Its primary target
OS is Linux.Next steps include:Support for Windows and OSXSupport for distributed (MPI) MUMPSInstallationpython-mumpsworks with Python 3.10 and higher on Linux, Windows and Mac.The recommended way to installpython-mumpsis usingmamba/conda.mambainstall-cconda-forgepython-mumpspython-mumpscan also be installed from PyPI, however this is a more involved procedure
that requires separately installing the MUMPS library and a C compiler.Usage exampleThe following example shows how Python-MUMPS can be used to implement sparse diagonalization
with Scipy.importscipy.sparse.linalgasslafromscipy.sparseimportidentityimportmumpsdefsparse_diag(matrix,k,sigma,**kwargs):"""Call sla.eigsh with mumps support.See scipy.sparse.linalg.eigsh for documentation."""classLuInv(sla.LinearOperator):def__init__(self,A):inst=mumps.Context()inst.analyze(A,ordering='pord')inst.factor(A)self.solve=inst.solvesla.LinearOperator.__init__(self,A.dtype,A.shape)def_matvec(self,x):returnself.solve(x.astype(self.dtype))opinv=LuInv(matrix-sigma*identity(matrix.shape[0]))returnsla.eigsh(matrix,k,sigma=sigma,OPinv=opinv,**kwargs)Developmentpython-mumpsrecommendsSpin. Get spin with:pipinstallspinThen to build, test and installpython-mumps:spinbuild
spintest----lf# (Pytest arguments go after --)spininstall
Package: python-muranoclient
MuranoMurano Project introduces an application catalog, which allows application
developers and cloud administrators to publish various cloud-ready
applications in a browsable categorised catalog, which may be used by the
cloud users (including the inexperienced ones) to pick-up the needed
applications and services and composes the reliable environments out of them
in a “push-the-button” manner.PyPi- package installationLaunchpad project- release managementBlueprints- feature specificationsBugs- issue trackingSourceSpecsHow to ContributePython Muranoclientpython-muranoclient is a client library for Murano built on the Murano API.
It provides a Python API (themuranoclientmodule) and a command-line tool
(murano).Project ResourcesProject status, bugs, and blueprints are tracked on Launchpad:Client bug trackerhttps://launchpad.net/python-muranoclientMurano bug trackerhttps://launchpad.net/muranoDeveloper documentation can be found here:https://docs.openstack.org/murano/latest/Additional resources are linked from the project wiki page:https://wiki.openstack.org/wiki/MuranoLicenseApache License Version 2.0http://www.apache.org/licenses/LICENSE-2.0
Package: python-musicbrainz
The MusicBrainz client library is a development library geared towards
developers who wish to add MusicBrainz lookup capabilities to their
applications.The client library includes the following features:Lookup Audio CD metadata using CD Index DiscidsCalculate Relatable TRM acoustic fingerprintsSearch for artist/album/track titlesLookup metadata by name, TRM ids or MusicBrainz Ids
Package: python-musicbrainz2
python-musicbrainz2 provides simple, object oriented access to the
MusicBrainz web service. It is useful for applications like CD rippers,
taggers, media players, and other tools that need music metadata.The MusicBrainz Project (seehttp://musicbrainz.org) collects music
metadata and is maintained by its large and constantly growing user
community.Most of this package works on python-2.3 and later without further
dependencies. If you want to generate DiscIDs from an audio CD in the
drive, you need ctypes (already included in python-2.5) and libdiscid.
Package: python-musicpd
An MPD (Music Player Daemon) client library written in pure Python.Documentation:https://kaliko.gitlab.io/python-musicpdMPD Protocol:https://www.musicpd.org/doc/html/protocol.htmlCode:https://gitlab.com/kaliko/python-musicpdDependencies:NoneCompatibility:Python 3.6+Licence:GNU LGPLv3
Package: python-mwapi
A very simple and direct wrapper around the Mediawiki APIIntroductionThis library provides a very simple convenience wrapper around theMediawiki API. It is meant to closely mirror the interface provided bymw.ApiFeaturesThe library allows you to call Mediawiki APIs without having to deal without dealing with network calls. It also has authentication support and a few convenience methods.Non FeaturesThis is the anti-mwclient. It does not add another layer for you to understand over the welldocumentedMediawiki API, and it never will :)DocumentationMWApiclass MWApiClass representing a single API Session, with a single authenticated user.Useful Attributes:tokens              - Contains an edittoken & watchtoken (if populateTokens() has been called)is_authenticated    - Boolean indicating if the MWApi is sending authenticated requestsMethods defined here:__init__(self, host, api_path=’/w/api.php’)Create a MWApi instanceArguments:host        - Host to which to connect to. Must includehttp://orhttps://and no trailing slashapi_path    - Url to api.php on the host. Must start with /get(self, params)Makes an API request with the GET methodArguments:params - Parameters to send to the API. Varies depending on the action to be performed.login(self, username, password)Authenticates with the given credentials and logs in the user for the session.All further requests sent from this MWApi object will be signed as said user.Arguments:username - The username of the user to be authenticatedpassword - The password of the user to be authenticatedThrows:Throws an exception with (Message, Response) if Authentication failsNote:Passwords are sent as plaintext. This is a limitation of the Mediawiki API.Use a https host if you want your password to be securepopulateTokens(self)Populates thetokensattribute of the object withedittokenandwatchtoken.Requires that authentication has been performed already withlogin()post(self, params)Makes an API request with the POST methodArguments:params - Parameters to send to the API. Varies depending on the action to be performed.request(self, method, params)Makes a request to the API and returns a dictionary containing the resultsArguments:method - GET or POST, depending on which API is being calledparams - Parameters to send to the API. Varies depending on the action to be performed.ContactSupport requests and flames can be sent to me via several means.Email:yuvipanda@gmail.com. Twitter: @yuvipanda. IRC: yuvipanda on FreeNodeYou can file bugson Github.