Saravanan666/pypi-org huggingface dataset:
Package: marsutils
Mars UtilitiesUtilties for building better robot codeView the docs online atRead the DocsControlManagerControlManagerprovides a wrapper that makes making alternate control modes (alternate drivers, different controlers) incredibly simple. It is designed primarially for MagicRobot components, however, it should work with any type.Seeexample/for an example robot.UsageFirst, all of the controls must be implemented as classes that subclassmarsutils.ControlInterface. The primary control code defined in theteleopPeriodicmethod.
Then, you must define the_DISPLAY_NAMEfield which will be displayed on the dashboard autochooser.
You can set_SORTto prioritize certain interfaces, the higher the number, the higher on the chooser list.Because it is a magic bot component, you can access injected components.But you must make an emptyexecutefunction to be a valid magicbot function.After you have the control components there are two ways to create the manager.MagicBot magicIf you are using the MagicRobot framework you can use the@with_ctrl_managerdecorator to automagically set everything up. Just annotate your robot class with@with_ctrl_managerand you are done. It will magically detect anyControlInterfaces, construct theControlManagerand automatically call the periodic functions.Using the decorator also means you don't need to define anexecutefunction.ManuallyOtherwize, you must must set up manager by initializingControlManagerwith all of your componentsaftercreateObjectshas been called. This isnot technically possible with the MagicBot frameworkyet.self.control_manager=marsutils.ControlManager(self.xbox_ctrl,self.joystick_ctrl)After you have created the control manager, you must call its periodic functions. This means addingself.control_manager.teleopPeriodic()to yourteleopPeriodicfunction and so on for each function you use.
Package: martapy
MARTApyPython wrapper for MARTA realtime rail and bus APIs:http://www.itsmarta.com/app-developer-resources.aspxInstallationTo install viapip, just:$pipinstallmartapyOr, locally from the same directory assetup.py:$pythonsetup.pyinstallRailTo get a list of train arrivals:frommartapyimportRailClientrail_client=RailClient(api_key="your_api_key")arrivals=rail_client.arrivals()This returns an instance ofmartapy.rail.Arrivals(list)which
has a few handy methods to filter results further.For example, to print the destination and waiting time for upcoming
arrivals atPeachtree Center Station:frommartapyimportRailClientrail_client=RailClient(api_key="your_api_key")peachtree_station=rail_client.arrivals().by_station('peachtree')forarrivalinpeachtree_station:print("To:{}, When:{}".format(arrival.destination,arrival.waiting_time))With output that would look something like::To: Airport, When: Arriving
To: Lindbergh, When: 16 min
To: Doraville, When: 19 minFiltersTo narrow results,martapy.rail.Arrivals(list)has
a number of properties/methods:Arrivals byline:red_lineblue_linegreen_linegold_lineArrivals bydirection:northboundeastboundwestboundsouthboundArrivals bywaiting time:boardingarrivingarrivedArrivals grouped bystation name:Arrivals.stationsArrivals grouped bytrain ID:Arrivals.trainsArrivals associated with aspecific station:Arrivals.by_station('stationname')These can be chained as well for more specific results. For example, to
get all arrivals for the red line which are heading southbound:frommartapy.railimportRailClientrail_client=RailClient(api_key="your_api_key")arrivals=rail_client.arrivals().red_line.southboundOther propertiesEachArrivalsinstance returned is just a list ofmartapy.rail.Arrivalobjects, with properties similar to the filters
above (station, direction, event_time, line…). To get the original
JSON string back, useArrival.json.BusTo get a list of active buses:frommartapyimportBusClientbus_client=BusClient()buses=bus_client.buses()To get active buses for a particular route number, useBusClient.buses(route=111)(or any other route number)To filter this list down further, usefilter()on the returnedBuseslist. For example, to return onlyWestboundbuses:frommartapyimportBusClientbus_client=BusClient()buses=bus_client.buses().filter(direction='Westbound')
Package: marta-python
marta-pythonPython library for accessing MARTA real-time APIInstallingpip install marta-pythonUsingDeclare a new instance of the MARTARailClientorBusClientclass:frommartaimportRailClientrail_api=RailClient(api_key="MY_API_KEY")There are methods available for accessing MARTA train and bus data, many of which accept optional parameters to filter the results.frommartaimportRailClient,BusClient,Direction,TrainLinerail_api=RailClient(api_key="MY_API_KEY")bus_api=BusClient(api_key="MY_API_KEY")# Get all buses (via legacy API)buses=bus_api.get_buses()# Get buses by routebuses=bus_api.get_buses(route=1)# Get buses by route and stop_idbuses=bus_api.get_buses(route=1,stop_id=900800)# Get buses by route and vehicle_idbuses=bus_api.get_buses(route=1,vehicle_id=1405)# Get buses by route and timepointbuses=bus_api.get_buses(route=1,time_point="West End Station")# Get buses by route, stop_id and vehicle_idbuses=bus_api.get_buses(route=1,stop_id=900800,vehicle_id=1405)# Get all rail station arrivalsarrivals=rail_api.get_arrivals()# Get trains by line, station and directionarrivals=rail_api.get_arrivals().on_line(TrainLine.RED).arriving_at("FIVE POINTS STATION").heading(Direction.NORTH)There are other train and bus methods available that utilize other MARTA APIs.frommartaimportBusClient,RailClientbus_api=BusClient(api_key="MY_API_KEY")rail_api=RailClient(api_key="MY_API_KEY")# Get all bus locations (via GTFS API) (preferred)bus_locations=bus_api.get_bus_locations_from_gtfs()# Get all bus routes (via real-time map API)bus_locations=bus_api.get_bus_locations_from_map()# Get all trains (via real-time API)trains=rail_api.get_real_time_trains()# Get all trains (via secondary real-time map API)trains=rail_api.get_trains_from_map()Each method returns a list of objects that represent the trains or buses.
Package: martian-api
Martian Node.js LibraryThe martian python library allows developers to easily access the martian api.This package should only be used server-side. Using this package client-side would expose your secret key.Installationpip install martian_apiUsageMartian allows you to easily access AI models and to log the outputs from AI models.Logging values:frommartian_apiimportlog_to_martianinputs=["The","inputs","to","your","function"]outputs="Your outputs"logToMartian({"api_key":YOUR_MARTIAN_API_KEY},inputs,outputs,{"martian_name":"your_function"})Logging a function:frommartian_apiimportwith_martian@with_martian({"api_key":YOUR_MARTIAN_API_KEY})defyour_function(args){//yourfunctiondefinition}Note thatwith_martianexpects a pure function. So, when defining a function in a class
which uses thewith_martiandecorator, only the arguments passed into the function are stored.frommartian_apiimportwith_martianclassExample():def__init__(self):self.y=1# This function does not use variables from self, so with_martian can be used@with_martian({"api_key":YOUR_MARTIAN_API_KEY})defpure_function(self,x):returnx+1# This function does use variables from self, so with_martian cannot be useddefimpure_function(self,x):result=x+ylog_to_martian({"api_key":YOUR_MARTIAN_API_KEY},[x,y],result{"martian_name":"impure_function"})returnresult
Package: martian-python
Martian Python API libraryThe Martin Python library is a drop in replacement for OpenAI packageDocumentationThe API documentation can be foundhere.Installationpipinstallmartian-pythonUsagefrommartianimportOpenAIclient=OpenAI(api_key="My MARTIAN Key",# defaults to os.environ.get("MARTIAN_API_KEY"))chat_completion=client.chat.completions.create(messages=[{"role":"user","content":"Say this is a test",}],model="router",# If more than one model is specified, the router chooses the best among them# model=["gpt-3.5-turbo", "claude-v1"])
Package: martin-binance
Profitable, fault-tolerant, adaptable to the marketModified MartingaleCyclic grid strategy for SPOT marketFree trading system for crypto exchanges:Binance, Bitfinex, Huobi, OKX, Bybit,martin-binance<--> exchanges-wrapperDisclaimerAll risks and possible losses associated with use of this strategy lie with you.
Strongly recommended that you test the strategy in the demo mode before using real bidding.Important noticesAfter update to2.1.0, the configuration filescli_XX_AAABBB.pyfor all running trading pairs
should be updated, also update the configuration filesexch_srv_cfg.tomlandms_cfg.toml. Use templates for reference.You cannot run multiple pairs with overlapping currencies on the same account!Valid: (BTC/USDT), (ETH/BUSD), (SOL/LTC)Incorrectly: (BTC/USDT), (ETH/USDT), (BTC/ETH)As a result of the mutual impact on the operating balance sheet, the liquidity control system will block the work.ReferencesDetailed information about use this strategy placed towikiTrade ideaQuick startBack testing and parameters optimizationReferral linkCreate account onBinanceand get 10% discount on all trading feeCreate account onHUOBIand will get 50 % off trading feesCreate account onBitfinexand get 6% rebate feeCreate account onOKEXand get Mystery Boxes worth up to $10,000Create account onBybitand get exclusive referral rewardsAlso, you can start strategy onHetznercloud VPS only for 4.75 € per monthDonateUSDT(TRC20) TU3kagV9kxbjuUmEi6bUym5MTXjeM7Tm8K
Package: martinez
martinezIn what followspythonis an alias forpython3.5orpypy3.5or any later version (python3.6,pypy3.6and so on).InstallationInstall the latestpip&setuptoolspackages versionspython-mpipinstall--upgradepipsetuptoolsUserDownload and install the latest stable version fromPyPIrepositorypython-mpipinstall--upgrademartinezDeveloperDownload the latest version fromGitHubrepositorygitclonehttps://github.com/lycantropos/martinez.gitcdmartinezInstallpythonsetup.pyinstallUsage>>>frommartinez.contourimportContour>>>frommartinez.pointimportPoint>>>frommartinez.polygonimportPolygon>>>left_polygon=Polygon([Contour([Point(0.0,0.0),Point(2.0,0.0),Point(2.0,2.0),Point(0.0,2.0)],[],True)])>>>right_polygon=Polygon([Contour([Point(1.0,1.0),Point(3.0,1.0),Point(3.0,3.0),Point(1.0,3.0)],[],True)])>>>frommartinez.booleanimportOperationType,compute>>>compute(left_polygon,right_polygon,OperationType.INTERSECTION)Polygon([Contour([Point(1.0,1.0),Point(2.0,1.0),Point(2.0,2.0),Point(1.0,2.0)],[],True)])>>>compute(left_polygon,right_polygon,OperationType.UNION)Polygon([Contour([Point(0.0,0.0),Point(2.0,0.0),Point(2.0,1.0),Point(3.0,1.0),Point(3.0,3.0),Point(1.0,3.0),Point(1.0,2.0),Point(0.0,2.0)],[],True)])>>>compute(left_polygon,right_polygon,OperationType.DIFFERENCE)Polygon([Contour([Point(0.0,0.0),Point(2.0,0.0),Point(2.0,1.0),Point(1.0,1.0),Point(1.0,2.0),Point(0.0,2.0)],[],True)])>>>compute(left_polygon,right_polygon,OperationType.XOR)Polygon([Contour([Point(0.0,0.0),Point(2.0,0.0),Point(2.0,1.0),Point(1.0,1.0),Point(1.0,2.0),Point(0.0,2.0)],[],True),Contour([Point(1.0,2.0),Point(2.0,2.0),Point(2.0,1.0),Point(3.0,1.0),Point(3.0,3.0),Point(1.0,3.0)],[],True)])original C++ implementation can be invoked by importing from_martinezmodule instead.DevelopmentBumping versionPreparationInstallbump2version.Pre-releaseChoose which version number category to bump followingsemver
specification.Test bumping versionbump2version--dry-run--verbose$CATEGORYwhere$CATEGORYis the target version number category name, possible
values arepatch/minor/major.Bump versionbump2version--verbose$CATEGORYThis will set version tomajor.minor.patch-alpha.ReleaseTest bumping versionbump2version--dry-run--verbosereleaseBump versionbump2version--verbosereleaseThis will set version tomajor.minor.patch.Running testsInstall dependenciespython-mpipinstall--force-reinstall-rrequirements-tests.txtPlainpytestInsideDockercontainer:withCPythondocker-compose--filedocker-compose.cpython.ymlupwithPyPydocker-compose--filedocker-compose.pypy.ymlupBashscript (e.g. can be used inGithooks):withCPython./run-tests.shor./run-tests.shcpythonwithPyPy./run-tests.shpypyPowerShellscript (e.g. can be used inGithooks):withCPython.\run-tests.ps1or.\run-tests.ps1cpythonwithPyPy.\run-tests.ps1pypy
Package: martINI
martINI is an extended facility for utilizingini filesin python.
martINI includes API, command-line, and web interfaces.
martINI is built on theConfigParsermodule,
which is part of python’s standard library.Command Line ToolsmartINI comes with several command line tools for manipulating .ini
files:ini-get: get key or section values from a .ini filesini-set: set .ini file valuesini-delete: delete .ini key-value pairs from a .ini filesini-munge: combine several .ini filesRunning the commands will display usage information.TODOConsider refactoring to useINIToolsinstead ofConfigParser.–http://k0s.org/portfolio/software.html#martini
Package: martini-sour
martini_sour#FunctionalityHelp setup titratable martini simulations and analyze them.ContributionsThe code development of polyply is done
ongithub. Contributions are welcome asbug reportsandpull requestsfrom everyone.LicenseMartini_sour is distributed under the Apache 2.0 license.Copyright 2021 University of Groningen

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.The full text of the license is available in the source repository.
Package: martinsimplecalculator
This is a verry simple calculator.This is the difrent things you can do: (thiese commands are examples and after 'returns' there is what comes out after doing that command)add_num(1,1)returns 2subtract_num(2,1)returns 1multiply_num(5,2)returns 10divide_num(10,2)returns 5exponent_num(2,10)returns 1024Change Log==========0.0.3 (19/10/2020)-------------------Changed Changelog
Package: martypy
martypyPython library to communicate with Marty the Robot V1 and V2 by RoboticalSee the API DocumentationTo regenerate documentation:pip install -r dev-requirements.txtpydoc-markdown --server --open
OR, automatically:run docgen.bat (or docgen.sh on Mac/Linux) from Python environment (will put the contents of the formatted docs into clipboard)How to run example scriptsIf you cloned the repository or downloaded the source code to try theexample scripts,
you will need to make sure you have MartyPy installed before you can run the examples.The easiest way to install MartyPy is with thepip install martypyscript as explained instep 2 here.Once martypy is installed you can run each example using python.
The following (for the dance example) assumes you have connected your marty using the USB cable to a Windows computerpython example_dance.py USBTo run the sound example over WiFi when your Marty is connected on IP address 192.168.86.10, use:python example_sound.py WiFi 192.168.0.10If you would like to make modifications to the martypy library itself, it will be better to install
it from source using the commandpip install --editable /path/to/martypy/repo(replacing/path/to/martypy/repoas appropriate of course).If you do not want to "pip install" the MartyPy library, you can add the following 4 lines at the
top (before any other code) of each script you want to run:importsysimportpathlibcur_path=pathlib.Path(__file__).parent.resolve()sys.path.append(str(cur_path.parent.resolve()))
Package: maru
MARuis a morphological analyzer for Russian, written in Python, powered by machine learning and neural networks.Installation$ pipenv install maruor$ pipenv install maru[gpu]for installation with Tensorflow GPU support.You can also just usepip(though you should definitely take a look atpipenv).What’s in the Box?✨ Morphological analysis with contextual disambiguation usingUniversal Dependenciestags.🌈 Trained via various machine learning methods: linear model, CRF, deep neural network.🔮 Speed/accuracy trade-off between different methods.🍰 Vocabulary-based lemmatization, built on top ofpymorphy2.UsageFirst, create amaru.analyzer.Analyzerobject using the factory method:>>importmaru>>analyzer=maru.get_analyzer(tagger='crf',lemmatizer='pymorphy')Then, analyze some text:>>analyzed=analyzer.analyze(['мама','мыла','раму'])# note that this returns an iterator>>formorphinanalyzed:...print(morph)...Morph(word='мама',lemma='мама',tag=Tag(pos=NOUN,animacy=Anim,case=Nom,gender=Fem,number=Sing))Morph(word='мыла',lemma='мыть',tag=Tag(pos=VERB,aspect=Imp,gender=Fem,mood=Ind,number=Sing,tense=Past,verbform=Fin,voice=Act))Morph(word='раму',lemma='рама',tag=Tag(pos=NOUN,animacy=Inan,case=Acc,gender=Fem,number=Sing))Other available taggers that you can pass tomaru.get_analyzerare'linear','rnn', and'pymorphy'.
Another available lemmatizer is'dummy'(no actual lemmatization, slightly improves inference speed).You can refer to the following table when choosing an algorithm to use:Full tag accuracy (per token, per sentence) and inference speedTaggerNews (Lenta)Social (VK)Literature (JZ)AllInference speedPymorphy77.24%12.85%72.71%18.84%73.16%10.91%74.43%14.85%49000 tokens/secLinear95.00%61.73%91.64%59.51%93.00%57.87%93.26%59.62%26500 tokens/secCRF95.55%64.53%91.82%61.27%93.59%63.96%93.70%62.95%5500 tokens/secRNN97.65%79.33%95.43%75.88%95.84%73.60%96.34%76.14%1000 tokens/secAccuracy was measured on theMorphoRuEval-2017test set.
Inference speed was estimated on a system with 32 GB RAM, Intel i7 6700K as CPU and GeForce GTX 1060 as GPU.
RNN performance is given for single sentence inference on GPU. An addition of batch inference in the future can greatly improve it.
Package: marude
MarudeMarusiademo interface - an http api client which allows to automatically convert russian short texts into speech usingvk cloud.InstallationTo create a conda environment and install dependencies use the following command:condacreate-fenvironment.ymlThen activate created environment:condaactivatemarudeUsageAfter the environment is set up, the app can be used from the command line:python-mmarudetts'Привет, мир'-mpavel-pmessage.mp3The provided text (which must be 1024 characters long or shorter) will be converted into speech and saved as an audiofilemessage.mp3. By default the file is saved atassets/message.mp3.The module can be used programmatically as well. First, install the module throughpip:pipinstallmarudeThen run your script, which may look like this (seeexample):fromtastyimportpipefrommarudeimportCloudVoiceClient,Voiceif__name__=='__main__':client=CloudVoiceClient(Voice.MARIA)withopen('message-1.mp3','wb')asfile:_='Съешь еще этих мягких французских булок'|pipe|client.tts|pipe|file.writewithopen('message-2.mp3','wb')asfile:_='да выпей чаю'|pipe|client.tts|pipe|file.write
Package: maruko
Maruko is malware crawler inspired by ‘ちびまる子ちゃん’This script crawl following sources.Malware Domain List:http://www.malwaredomainlist.com/hostslist/mdl.xmlVX Vault:http://vxvault.siri-urz.net/URL_List.phpMalc0de:http://malc0de.com/rssInstallationDependenciesMaruko use python-magic module.python-magicis a python interface to the libmagic file type identification library. It is dependent on libmagic. You need to installlibmagicbefore you install maruko.On OSX:When using Homebrew:brew install libmagicWhen using macports:port install filePyPIThe recommended process is to install the PyPI package, as it allows easily staying update.$ pip install marukogithubDownload fromhttps://github.com/tkmru/maruko/.Let’s push star!!$ git clone git@github.com:tkmru/maruko.git
$ cd maruko
$ python setup.py installUsageDownloaded malware is stored in/opt/malware/unsorted/by default.$ sudo maruko‘-p’ change stored path.$ sudo maruko -p <path>License“THE BEER-WARE LICENSE”If we meet some day, and you thinkthis stuff is worth it, you can buy me a beer in return.
Package: marun
# marun - Maven Artifact Runner* deploying jar files and their dependencies from maven repositories* run easilyMarun is a tool to install and run Java programs from maven repositories.It has no capability to compile, archive and do other build commands unlike Apache Maven or Gradle, but it can read pom.xml and resolve dependencies using Apache Ivy.## usage1. install marun```> sudo pip install marun```2. install a jar (example: jruby)```> sudo marun install org.jruby:jruby-core:1.7.+```3. run```> sudo marun run jruby.Main -v```## configurationIt is expected that you have some private maven repositories.You can use Amazon S3(e.g. [aws-maven](https://github.com/spring-projects/aws-maven)), [Nexus](http://www.sonatype.org/nexus/), [Artifactory](https://www.jfrog.com/artifactory/) or a http server for your private repository.```#/etc/marun.conf...repositories=yours,jcenter[repository:yours]baseurl=http://......```## requirements* Java8* Python 2.7
Package: marutils
marutils - Utilities for working with MAR RCM outputsThis package contains utilities/tools that make it easier to open MAR RCM outputs.Load outputs straight into an xarray Dataset with standard dimensions names(time, y, x).Provide a path with a wildcard expression (*) to automatically load several years of MAR files at once, concatenating them along the time axis.Plays nicely with Dask - chunking options default to 365-366 days (but can be changed at will).Loaded Datasets are automatically "geo-aware" using the rioxarray.rioaccessor - no more trying to work out MAR's geo-referencing manually!Helper functions for turning X-hourly variables into continuous time series.Helper functions for masking.QuickStartimportmarutils# Open a time series for the 21st century.mar_outputs=marutils.open_dataset('MARv3.11.2/MAR*20*.nc')# Check out the coordinates.print(mar_outputs.coords)Coordinates:*x(x)float32-760000.0-740000.0-720000.0...660000.0680000.0*y(y)float32-1180000.0-1160000.0...1480000.01500000.0*SECTOR(SECTOR)float321.02.0*SECTOR1_1(SECTOR1_1)float321.0*time(time)datetime64[ns]2019-01-01T12:00:00...2019-12-31T12:...*ATMLAY3_3(ATMLAY3_3)float320.99974793spatial_refint640# What is proj.4 string for the geo-referencing of this dataset?print(mar_outputs.rio.crs.to_proj4())+proj=stere+lat_0=70.5+lon_0=-40+k=1+x_0=0+y_0=0+datum=WGS84+units=m+no_defs=TrueInstallationAt the moment, manually:git clone <repository>
cd <repository>
pip install -e .Soon to be available via pyPI.Working with X-hourly outputsTo return an X-hourly variable with a single, continuous hourly time variable:hourly_air_temperatures=marutils.xhourly.Xhourly_to_time(mar_outputs.TTH)Useful notesPixel corners vs centresIt's useful to remember that netCDF file geo-referencing treats X,Y coordinates as pixel (cell) centres. In contrast, the rasterio/GDAL data model treats X,Y coordinates as pixel upper-left corners.In the QuickStart section above we loaded a 20 km resolution dataset. The minimum and maximum X coordinates are -760000 and 680000 m respectively. These correspond to the centres of the min/max pixels.Through the.rioaccessor we can check on the bounds/complete spatial extent of the file:# What is the centre of the top-left cell? (xmin, ymin, xmax, ymax)mar_outputs.rio.bounds()(-770000.0,1510000.0,690000.0,-1190000.0)We can see that these bounds account for the 20 km pixel size of this dataset.CaveatsThe geo-referencing capabilities have so far been tested only for Greenland datasets. If you have problems trying to load other domains, please post an issue on this repository.
Package: marv
This package is part of the MARV Robotics Community Edition.MARV Robotics is a powerful and extensible data management platform,
featuring a rich dynamic web interface, driven by your algorithms,
configurable to the core, and integrating well with your tools to
supercharge your workflows.For more information please see:MARV RoboticswebsiteMARV RoboticsdocumentationMARV RoboticsGitLab project
Package: marv-cli
This package is part of the MARV Robotics Community Edition.MARV Robotics is a powerful and extensible data management platform,
featuring a rich dynamic web interface, driven by your algorithms,
configurable to the core, and integrating well with your tools to
supercharge your workflows.For more information please see:MARV RoboticswebsiteMARV RoboticsdocumentationMARV RoboticsGitLab project