Saravanan666/pypi-org huggingface dataset:
Package: maticbase
# BaseMatics ToolsThis is a Tools for basematic applications… [Python Packaging User
Guide][packaging guide]’s [Tutorial on Packaging and Distributing
Projects][distribution tutorial].This project does not aim to cover best practices for Python project
development as a whole. For example, it does not provide guidance or tool
recommendations for version control, documentation, or testing.[The source for this project is available here][src].Most of the configuration for a Python project is done in thesetup.pyfile,
an example of which is included in this project. You should edit this file
accordingly to adapt this sample project to your needs.This is the README file for the project.The file should use UTF-8 encoding and can be written using
[reStructuredText][rst] or [markdown][md use] with the appropriate [key set][md
use]. It will be used to generate the project webpage on PyPI and will be
displayed as the project homepage on common code-hosting services, and should be
written for that purpose.Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not a
good idea, although a simple “What’s New” section for the most recent version
may be appropriate.[packaging guide]:https://packaging.python.org[distribution tutorial]:https://packaging.python.org/en/latest/distributing.html[src]:https://github.com/pypa/sampleproject[rst]:http://docutils.sourceforge.net/rst.html[md]:https://tools.ietf.org/html/rfc7764#section-3.5“CommonMark variant”
[md use]:https://packaging.python.org/specifications/core-metadata/#description-content-type-optional
Package: matic-etl
Ethereum ETLEthereum ETL lets you convert blockchain data into convenient formats like CSVs and relational databases.Do you just want to query Ethereum data right away? Use thepublic dataset in BigQuery.Full documentation available here.QuickstartInstall Ethereum ETL:pip3installethereum-etlExport blocks and transactions (Schema,Reference):>ethereumetlexport_blocks_and_transactions--start-block0--end-block500000\--blocks-outputblocks.csv--transactions-outputtransactions.csv\--provider-urihttps://mainnet.infura.io/v3/7aef3f0cd1f64408b163814b22cc643cExport ERC20 and ERC721 transfers (Schema,Reference):>ethereumetlexport_token_transfers--start-block0--end-block500000\--provider-urifile://$HOME/Library/Ethereum/geth.ipc--outputtoken_transfers.csvExport traces (Schema,Reference):>ethereumetlexport_traces--start-block0--end-block500000\--provider-urifile://$HOME/Library/Ethereum/parity.ipc--outputtraces.csvStream blocks, transactions, logs, token_transfers continually to console (Reference):>pip3installethereum-etl[streaming]>ethereumetlstream--start-block500000-eblock,transaction,log,token_transfer--log-filelog.txt\--provider-urihttps://mainnet.infura.io/v3/7aef3f0cd1f64408b163814b22cc643cFind other commandshere.For the latest version, check out the repo and call>pip3install-e.>python3ethereumetl.pyUseful LinksSchemaCommand ReferenceDocumentationExporting the BlockchainQuerying in Amazon AthenaQuerying in Google BigQueryQuerying in KaggleAirflow DAGsPostgres ETLEthereum 2.0 ETLRunning Tests>pip3install-e.[dev,streaming]>exportETHEREUM_ETL_RUN_SLOW_TESTS=True
>pytest-vvRunning Tox Tests>pip3installtox
>toxRunning in DockerInstall Dockerhttps://docs.docker.com/install/Build a docker image> docker build -t ethereum-etl:latest .
 > docker image lsRun a container out of the image> docker run -v $HOME/output:/ethereum-etl/output ethereum-etl:latest export_all -s 0 -e 5499999 -b 100000 -p https://mainnet.infura.io
 > docker run -v $HOME/output:/ethereum-etl/output ethereum-etl:latest export_all -s 2018-01-01 -e 2018-01-01 -p https://mainnet.infura.ioRun streaming to console or Pub/Sub> docker build -t ethereum-etl:latest -f Dockerfile .
 > echo "Stream to console"
 > docker run ethereum-etl:latest stream --start-block 500000 --log-file log.txt
 > echo "Stream to Pub/Sub"
 > docker run -v /path_to_credentials_file/:/ethereum-etl/ --env GOOGLE_APPLICATION_CREDENTIALS=/ethereum-etl/credentials_file.json ethereum-etl:latest stream --start-block 500000 --output projects/<your-project>/topics/crypto_ethereumProjects using Ethereum ETLGoogle- Public BigQuery Ethereum datasetsNansen by D5- Analytics platform for Ethereum
Package: maticinfos
# BaseMatics ToolsThis is a Tools for basematic applications… [Python Packaging User
Guide][packaging guide]’s [Tutorial on Packaging and Distributing
Projects][distribution tutorial].This project does not aim to cover best practices for Python project
development as a whole. For example, it does not provide guidance or tool
recommendations for version control, documentation, or testing.[The source for this project is available here][src].Most of the configuration for a Python project is done in thesetup.pyfile,
an example of which is included in this project. You should edit this file
accordingly to adapt this sample project to your needs.This is the README file for the project.The file should use UTF-8 encoding and can be written using
[reStructuredText][rst] or [markdown][md use] with the appropriate [key set][md
use]. It will be used to generate the project webpage on PyPI and will be
displayed as the project homepage on common code-hosting services, and should be
written for that purpose.Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not a
good idea, although a simple “What’s New” section for the most recent version
may be appropriate.[packaging guide]:https://packaging.python.org[distribution tutorial]:https://packaging.python.org/en/latest/distributing.html[src]:https://github.com/pypa/sampleproject[rst]:http://docutils.sourceforge.net/rst.html[md]:https://tools.ietf.org/html/rfc7764#section-3.5“CommonMark variant”
[md use]:https://packaging.python.org/specifications/core-metadata/#description-content-type-optional
Package: matildapeak-chronicler-transmitter
Thematildapeak-chronicler-transmittermodule is a set of utilities
employed byMatilda Peak’sEmergent Behaviour Platform.Chronicler TransmitterThis class provides basicpayloadtransmission to Chronicler and is used
byGartenand other data adapters to feed Chronicler with processable data.
The payload is a keyword-value dictionary that is passed to connected
PatterneerRunnersencapsulated in aProtocol Bufferobject.For convenience The class provides a synchronous posting method (post())
and an asynchronous posting method (post_async()) but you’re advised to
use one or the other, not mix them in a single application.Typical usage:from matildapeak.chronicler_transmitter import ChroniclerTransmitter

ct = ChroniclerTransmitter(URL, RESOURCE, APP_ID, APP_CODE)
ct.post_async({'field': 'value'})

ct.stop_async()
Package: matildapeak-guesstag
A simple utility toguessthe next GitLab CI tag value that can
be used along withpyconf.This utility gets the nearest tag and, if found to be sensible,
prints what it believes would be the next logical version.If the environment variableCI_COMMIT_TAGis defined (which is normal
for tagged builds) this utility simply returns (prints) the defined value -
i.e. on tagged builds this utility prints the tag.If a tag cannot be found the utility will return the value
defined in thepyconf.ymlfile or, if it cannot be found,0.0.0.InstallationGuesstag is published onPyPIand can be installed from
there:pip install matildapeak-guesstagGet in touchReport bugs, suggest features or view the source codeon GitLab.
Package: matildapeak-lablabel
lablabelis labelling utility for GitLab projects. Given a text file of
label definitions this utility attempts to create those labels in the given
GitLab project.The text file defines the name, colour, priority and description of each
of your project labels. Now, armed with a suitable file you can setup
all your projects quickly using a consistent label style.InstallationLabLabel is published onPyPIand can be installed from
there:pip install matildapeak-lablabelDocumentationLabLabel documentation is available onRead The Docs.Get in touchReport bugs, suggest features or view the source codeon GitLab.
Package: matildapeak-protobuf
Cross-product protocol buffersA library of python bindings for protocol buffer definitions used by one or
more products in the Matilda Peak product suite.The protocol buffers are used across multiple components and languages.
At the outset we anticipate supporting Python, and Java/Scala. The root
of all packages issrc/mainas required by build tools likeGradle.
From there the directory must bematildapeakfollowed by component
directories or acommondirectory. An example protocol message
file might be:src/main/matildapeak/patterncomponent/DelayMessage.protoInstallationThe protocol buffers are published onPyPIand can be installed from
there:pip install matildapeak-prototobufGet in touchReport bugs, suggest features or view the source codeon GitLab.Fixing the Python importThe Python protocol buffer bindings userelativeimports and do not
function properly (at least this is true of Python 3.6 and
protobuf 3.1.0).The issue appears to be welldocumentedbut a workaround is to adjust
the system path to include the directory of the component’s
site package. In a clean virtual environment this is easily achieved
with the following:import os
import sys
sys.path.append(os.path.join(sys.path[-1], 'patterncomponent'))Rather than use[-1]asaferapproach might be to locate thesite-packagesdirectory in the system path and use that - it
may not be the last entry on the path.
Package: matildapeak-pyconf
pyconfis a configuration utility written in Python 3.pyconfattempts to replicate the role of the unixAutoconfutility.
Where Autoconf relies on.infiles and anautoconf.acfilepyconfrelies on.pinfiles and apyconf.ymlfile.Refer to theTUTORIAL.mdfile in theGitLabsource repository
for instructions on how to use it and how its configuration files work.
Package: matildapeak-scoly-api
Scoly APIA Python 3 API package for theScolyframework.UsageCreate aScolyAPIinstance for eachLocationyou're dealing with: -from scoly_api.client import Scoly
from datetime import datetime
client = Scoly(
    scoly_url="127.0.0.1:8000",
    location="Red Dwarf",
    location_api_access_code="033589a1-c17d-45e0-bbaa-a5122300c9f3",
)And then add sensor events, which will be transmitted toScolywhen the
cache is full: -client.add_sensor_data(
    sensor="Rimmer",
    data={"timestamp": "2023-05-30T00:00:00Z",
          "battery": 67,
          "presence": False,
          "celsius": 23.4,
          "lux": 45.6}
)By default the cache will be flushed when it contains 50 events or if the
cache contents are older than 6 minutes. You can set your own
values when you initialise theScolyAPIinstance with some extra parameters.
To set a cache size of 10 and maximum age of 2 minutes initialise the ScolyAPI
instance like this: -client = Scoly(
    [...],
    sensor_event_cache_size = 10,
    sensor_event_cache_period = 120,
)If either value is zero sensor data will be transmitted on each call toadd_sensor_data().There is no background task. After 6 minutes events will not be transmitted,
instead they will b e transmitted on the next call toadd_sensor_data().
Alternatively, you can also flush cached data immediately by callingflush(): -client.flush()BuildingThe project is managed byPoetry, so you can build and install the project
forcing version 1.0.0 with: -rm -rf dist
poetry version 1.0.0
poetry buildAnd then install locally withpip: -pip install dist/*.whlWhen you're done you can uninstall the API package with pip: -pip uninstall -y matildapeak_scoly_apiContributingThe project uses: -Poetryfor dependency management and packagingPre-committo enforce linting of files prior to committing them to the
upstream repositoryConventional Commitscommit message formatBlackas a code formatterYouMUSTcomply with these choices in order to  contribute to the project.To get started review the pre-commit utility and the conventional commit style
and then set-up your local clone by following theInstallationandQuick Startsections: -poetry shell
poetry install --with dev
pre-commit install -t commit-msg -t pre-commitNow the project's rules will run on every commit, and you can check the
current health of your clone with: -pre-commit run --all-files
Package: matildapeak-yacker
yackeris Python utility that wrapsPackerwith the ability to define
template and variable files in YAML.Sadly, Packer (at the moment) only supports template definitions in JSON,
which (for me) isn’t a particularly human-friendly file format (I like to add
comments and break lines to make them easier to read). So, here’s a utility
that allows you to define your files using a much more friendly format.Installationyackeris published onPyPIand can be installed from there:pip install matildapeak-yackerDocumentationYacker documentation is available onRead The Docs.Get in touchReport bugs, suggest features or view the source codeon GitLab.
Package: matillioncli
DescriptionCLI tool for running Matillion jobs. Names are case-sensitive. Prompts for instance address, api user and api key on the first run.UsageMake sure you have python3 on your machine (3.6 < 3.9)Installationpip install matillioncli            # install
pip install matillioncli --upgrade  # updateRun from commandlinematillioncli-r<group>.<project>.<job>Run in interactive modematillioncliFirst you will select your environment (dev/test/prod, for example). You can search jobs usinglist <search pattern>and run your recent search usingrun list, or you can run a specific job usingrun <job name>. Running jobs and their states can be displayed withstatuscommand.Optional argumentsusage:matillioncli[-h][-v][-d][-c][-rRUN]optionalarguments:-h,--helpshowthishelpmessageandexit-v,--versiondisplaypackageversion-d,--debuglogtoconsole-c,--configurationre-inputconfigurationvalues-rRUN,--runRUNstartorchestrationjobwithoutinteractivemode(<group>.<project>.<job>)CommandsCMDACTIONhelpDisplay helpstatusDisplay status or queued jobsrunjob_nameRun job in current contextrun listRun recently listed jobslistsearch_patternList jobs in current contextenvSwitch group/project contextexitExitReferencesAPImap
Package: matillion_columns
# How to RunBefore you do anything, make sure you’ve followed [this play](https://edusource.atlassian.net/wiki/spaces/PLAYB/pages/510460716/Create+AWS+Access+Credentials+and+Configure+AWS+CLI).### Installation`bash brew install python2 pip install--usermatillion-columns`### RunOnce you’ve followed these steps, you should be able to run the script, using (it may take a few seconds to run, depending on the size of the file):matillion-columns [OPTIONS] csv_file.csvFor more help info, run:matillion-columns -h
Package: matip
Matip is an open source,test automation tool for native and hybrid apps,
tested on emulators and real devices.Supported Python VersionsPython 2.6, 2.7Python 3.2, 3.3InstallingIf you havepipon your system, you can simply install or upgrade the Python bindings:pip install -U matipAlternately, you can download the source distribution fromPyPI <http://pypi.python.org/pypi/matip>,unarchive it, and run:python setup.py installNote: both of the methods described above installmatipas a system-wide package  That will require administrative/root access to ther machine.  You may consider using avirtualenvto create isolated Python environments instead.Example :open a native appsfrom matip import driver

capabilities = {}
capabilities["app"] = "c:/selendroid-test-app.apk"
capabilities["device"] = "0123456789ABCDEF"
capabilities["model"] = "native"

driver = driver.MobileDriver(capabilities)

...

driver.quit()
Package: matiz
matizPython's 3.7 dataclasses got maried with pyyaml.Installation:pipinstallmatizUsage example:importdataclassesimportmatizfrommatizimportfields@dataclasses.dataclassclassSome(matiz.ObsoleteAble):id:int=fields.Integer()mac:str=fields.MacAddress()ip:str=fields.IPv4()version:int=fields.Integer(default=411)Now theSomeobject can be created as a pure python object (thanks todataclass)
it is equipped with__init__,__repr__,__eq__and some other methods.>>>obj=Some(123,'aa:bb:cc:11:22:33','192.168.11.6')>>>objSome(id=123,mac='aa:bb:cc:11:22:33',ip='192.168.11.6',version=411)>>>print(obj)!iz/Someid:123ip:192.168.11.6mac:aa:bb:cc:11:22:33version:411It's attributes are regular python attributes:>>>obj.id123>>>obj.mac'aa:bb:cc:11:22:33'>>>obj.ip'192.168.11.6'>>>obj.version=0# can be assigned>>>print(repr(obj))Ints(id=123,mac='aa:bb:cc:11:22:33',ip='192.168.11.6',version=0)It can be also deserialized from yaml directly to the custom object:>>>yaml_string="""!iz/Someid: 22001ip: 12.13.14.15mac: aa:bb:cc:11:22:33version: 0""">>>importyaml>>>obj2=yaml.load(yaml_string,Loader=yaml.Loader)>>>repr(obj2)Some(id=22001,mac='aa:bb:cc:11:22:33',ip='12.13.14.15',version=0)To be further documented...
Package: matlab-connection
matlab_connectionthis package is designed to streamline reading from and writing data to MATLAB from pythonPurpose:The matlab.engine library from Mathworks is impressive in that it allows python to connect to a MATLAB session, but can become a little long winded when interacting with numpy and calling functions.Thematlab_connectionmodule contains a class that allows get and put variables, as well as call functions and run m-files in a straightforward, extensible manner.Features:get matlab variables into pythonput python variables into MATLABrun an script (not as a function) from pythoncall a MATLAB function from pythonInstallation:following pip installation, move the filesfunction_from_python.mandscript_from_python.mfrom the installation directory (ususally PYTHONPATH\Lib\site-packages\matlab_connection) into your MATLAB search path
Package: matlab-kernel
PrerequisitesInstallJupyter Notebookand theMatlab engine for Python.InstallationInstall using:$ pip install matlab_kernelorpip installgit+https://github.com/Calysto/matlab_kernelfor the dev version.To use the kernel, run one of:$ jupyter notebook
# In the notebook interface, select Matlab from the 'New' menu
$ jupyter qtconsole --kernel matlab
$ jupyter console --kernel matlabTo remove from kernel listings:$ jupyter kernelspec remove matlabConfigurationThe kernel can be configured by adding anmatlab_kernel_config.pyfile to thejupyterconfig path.  TheMatlabKernelclass offersplot_settingsas a configurable traits.
The available plot settings are:
‘format’, ‘backend’, ‘width’, ‘height’, and ‘resolution’.cat~/.jupyter/matlab_kernel_config.pyc.MatlabKernel.plot_settings=dict(format='svg')TroubleshootingKernel Times Out While StartingIf the kernel is not starting, try running the following from a terminal.python-mmatlab_kernel.checkPlease include that output if opening an issue.Kernel is Not ListedIf the kernel is not listed as an available kernel, first try the following command:python-mmatlab_kernelinstall--userIf the kernel is still not listed, verify that the following point to the same
version of python:whichpython# use "where" if using cmd.exewhichjupyterAdditional informationThe Matlab kernel is based onMetaKernel,
which means it features a standard set of magics.  For a full list of magics,
run%lsmagicin a cell.A sample notebook is availableonline.A note about plotting.  After each call to Matlab, we ask Matlab to save any
open figures to image files whose format and resolution are defined using the%plotmagic.  The resulting image is shown inline in the notebook.  You can
use%plot nativeto raise normal Matlab windows instead.Advanced Installation NotesWe automatically install a Jupyter kernelspec when installing the python package. This location can be found usingjupyter kernelspec list. If the default location is not desired, you can remove the directory for the octave kernel, and install usingpython-mmatlab_kernel install. Seepython-mmatlab_kernel install--helpfor available options.It has been reported that Matlab version 2016b works fine. However, Matlab 2014b does not work with Python 3.5.DevelopmentInstall the package locally:$ pip install -e .
$ python -m matlab_kernel installAs you make changes, test them in a notebook (restart the kernel between changes).
Package: matlablib
matlablibSuite of Matlab utilities ported over to PythonInstallationRun the following to install :pipinstallmatlablibUsageimportmatlablibasmlfrommatlablibimportclosefiguresfrommatlablibimportccfrommatlablibimportkeyboardfrommatlablibimportsayHeyfrommatlablibimportquit_earlyfrommatlablibimportkill_backgroundfrommatlablibimportgetPythonVariablesSay heyml.sayHey
Package: matlab_nbconvert
[![PyPI version](https://badge.fury.io/py/matlab_nbconvert.svg)](https://badge.fury.io/py/matlab_nbconvert)# matlab_nbconvertThis is an exporter for `nbconvert` that turns matlab-notebooks into neatly formatted matlab (`.m`) files. You need to have `nbconvert` installed.Usage: type `jupyter nbconvert --to matlab 'notebookname.ipynb'`, inserting your filename as needed.All cells in the resulting `.m` files are delimited by the matlab sectioning `%%`, which means you can run your code as sections in Matlab like you would in jupyter. All code cells have the heading "Cell [X]", where X is the output number present in your notebook.You can then turn these `.m` files into _Matlab Live Scripts_, which is Mathwork's version of a notebook. In future releases, I may release something like this as well.Install by cloning this repository, opening a terminal in the directory, and typing `pip install .`, or get the package from pypi by typing `pip install matlab_nbconvert`.
Package: matlab-tictoc
MATLAB Tic TocA Python module to make timing in python easier by mimicing MATLAB'sticandtocfunctions.ticstarts a timer by recording the current time, andtocuses the start time to find the elapsed time.The includedfunc_timerdecorator usesticandtocto give the elapsed time of the wrapped function.Usagefrom tictoc import tic, toc

tic()              # starts the global timer
timer = tic()      # assigns an instance of the Timer class to the timer var without affecting the global timer

toc()              # Prints elapsed time from tic() call
toc(timer)         # Prints elapsed time for the timer given

time = toc(timer)  # Assigns elapsed time to a variable

timer.reset()      # Resets the timer var start time

tic()              # Restarts the global timerExamplesfrom time import sleep
from tictoc import tic, toc, func_timer


tic()  # starts global timer
sleep(1)
toc()
sleep(2)
toc()Elapsed time is 1.00547 seconds.Elapsed time is 3.00886 seconds.timer = tic()
sleep(1)
print(f'Timer Assigned to var: {toc(timer)}')
print(f'Global Timer: {toc()}')Timer Assigned to var: 1.0057699Global Timer: 4.013537@func_timer
def func():
    sleep(2)

func()Elapsed time for function func is 2.00556969 seconds.