Saravanan666/pypi-org huggingface dataset:
Package: aiomsa
aiomsaaiomsais a Python 3.7+ framework built usingasyncio. At its core,aiomsaprovides a simple and standardized way to write xApps that can be deployed as
microservices in Python.Installationaiomsacan be installed from PyPI.pipinstallaiomsaYou can also get the latest code from GitHub.poetryaddgit+https://github.com/facebookexternal/aiomsaGetting StartedThe follwing example shows how to useaiomsato create a simple xApp for subscribing
to the E2T service for a particular custom service model.importasyncioimportaiomsaimportaiomsa.abcfromonos_ric_sdk_pyimportE2Client,SDLClientfrom.modelsimportMyModelasyncdefrun(e2:aiomsa.abc.E2Client,e2_node_id:str)->None:subscription=awaite2.subscribe(e2_node_id,service_model_name="my_model",service_model_version="v1",subscription_id="my_app-my_model-sub",trigger=bytes(MyModel(param="foo")),actions=[aiomsa.abc.RICAction(id=1,type=aiomsa.abc.RICActionType.REPORT,subsequent_action_type=aiomsa.abc.RICSubsequentActionType.CONTINUE,time_to_wait=aiomsa.abc.RICTimeToWait.ZERO,)],)asyncfor(_header,message)insubscription:print(message)asyncdefmain()->None:asyncwithE2Client(app_id="my_app",e2t_endpoint="e2t:5150")ase2,SDLClient(topo_endpoint="topo:5150")assdl:asyncfore2_nodeinsdl.watch_e2_connections():asyncio.create_task(run(e2,e2_node.id))if__name__=="__main__":aiomsa.run(main())
Package: aio-msgpack-rpc
aio-msgpack-rpcPure asyncio implementation of theMsgPack RPC.Requires Python >= 3.6.UsesstreamsAPI provided by theasynciostandard library.Just a simple implementation of the RPC layer.Installationpip install aio-msgpack-rpcExampleServerimportasyncioimportaio_msgpack_rpc# handlers can be defined on a class# they can either be async or plain functionsclassMyServicer:asyncdefsum(self,x,y):print(f"sum:{x},{y}")returnx+ydefnotification(self,msg):print(f"notification:{msg}")asyncdefmain():try:server=awaitasyncio.start_server(aio_msgpack_rpc.Server(MyServicer()),host="localhost",port=18002)whileTrue:awaitasyncio.sleep(0.1)finally:server.close()try:asyncio.get_event_loop().run_until_complete(main())exceptKeyboardInterrupt:passClientimportasyncioimportaio_msgpack_rpcasyncdefmain():client=aio_msgpack_rpc.Client(*awaitasyncio.open_connection("localhost",18002))# blocking rpc callsresult=awaitclient.call("sum",1,2)assertresult==3# one way notificationsawaitclient.notify("notification","hello")asyncio.get_event_loop().run_until_complete(main())BenchmarkSome basic performance benchmarks against the official implementation on my development machine.packagecall (QPS)notify (QPS)msgpack-rpc-python541411746aio-msgpack-rpc578186957
Package: aiomultiprocess
aiomultiprocessTake a modern Python codebase to the next level of performance.On their own, AsyncIO and multiprocessing are useful, but limited:
AsyncIO still can't exceed the speed of GIL, and multiprocessing only works on
one task at a time.  But together, they can fully realize their true potential.aiomultiprocess presents a simple interface, while running a full AsyncIO event
loop on each child process, enabling levels of concurrency never before seen
in a Python application.  Each child process can execute multiple coroutines
at once, limited only by the workload and number of cores available.Gathering tens of thousands of network requests in seconds is as easy as:asyncwithPool()aspool:results=awaitpool.map(<coroutinefunction>,<items>)Installaiomultiprocess requires Python 3.6 or newer.
You can install it from PyPI:$pip3installaiomultiprocessUsageMost of aiomultiprocess mimics the standard multiprocessing module whenever
possible, while accounting for places that benefit from async functionality.Running your asynchronous jobs on a pool of worker processes is easy:importasynciofromaiohttpimportrequestfromaiomultiprocessimportPoolasyncdefget(url):asyncwithrequest("GET",url)asresponse:returnawaitresponse.text("utf-8")asyncdefmain():urls=["https://jreese.sh",...]asyncwithPool()aspool:asyncforresultinpool.map(get,urls):...# process resultif__name__=='__main__':# Python 3.7asyncio.run(main())# Python 3.6# loop = asyncio.get_event_loop()# loop.run_until_complete(main())Take a look at theUser Guidefor more details and examples.For further context, watch the PyCon US 2018 talk about aiomultiprocess,"Thinking Outside the GIL":Slides available atSpeaker Deck.Licenseaiomultiprocess is copyrightJohn Reese, and licensed under
the MIT license.  I am providing code in this repository to you under an open
source license.  This is my personal repository; the license you receive to
my code is from me and not from my employer. See theLICENSEfile for details.
Package: aiomyorm
aiomyorm is a simple and easy-to-use ORM framework, which has a similar interface to Django and fully supports asyncio.FeaturesPerfect support for asyncio and uvloop.Simple and easy to use API, similar to Django.Support mysql and SQLite.InstallationpipinstallaiomyormGetting StartedfromaiomyormimportModel,IntField,StringField,SmallIntField,auto_incrementfromaiomyormimportset_config,close_db_connectionimportasyncioset_config(engine='sqlite',db='test.db')classTest(Model):__table__='test'pk=IntField(primary_key=True,default=auto_increment())id=StringField(50)age=IntField(comment='the age of student.')birth_place=StringField(50,default='china')grade=SmallIntField()asyncdefgo():insert_rows=awaitTest.insert(Test(pk=5000,age=18,birth_place='place1'),Test(pk=5001,age=21,birth_place='place2'),Test(pk=5002,age=19,birth_place='place3'))all=awaitTest.find()print('insert rows: ',insert_rows)forrinall:print(r)if__name__=='__main__':loop=asyncio.get_event_loop()loop.run_until_complete(Test.create_table())loop.run_until_complete(go())loop.run_until_complete(close_db_connection())the resultsto create table test.
   insert rows:  3
   pk:5000, id:, age:18, birth_place:place1, grade:0
   pk:5001, id:, age:21, birth_place:place2, grade:0
   pk:5002, id:, age:19, birth_place:place3, grade:0more use see the document:aiomyormDependenciesPython >= 3.5.3aiomysql(for MySQL)aiosqlite(for sqlite)TestsI have a simple test for you.It's better for you to test in avenv.firstgitclonegit@github.com:yulansp/aiomyorm.gitthenpipinstall-rrequirements.txtRecipe you must install MySQL and configure the user name and password
in thetests/test_mysql/config.pyfile.thenmaketestLicenseMIT
Package: aiomysensors
aiomysensorsPython asyncio package to connect to MySensors gateways.InstallationInstall this via pip (or your favourite package manager):pip install aiomysensorsExample"""Show a minimal example using aiomysensors."""importasynciofromaiomysensorsimportAIOMySensorsError,Gateway,SerialTransportasyncdefrun_gateway()->None:"""Run a serial gateway."""port="/dev/ttyACM0"baud=115200transport=SerialTransport(port,baud)try:asyncwithGateway(transport)asgateway:asyncformessageingateway.listen():print("Message received:",message)exceptAIOMySensorsErroraserr:print("Error:",err)if__name__=="__main__":try:asyncio.run(run_gateway())exceptKeyboardInterrupt:passCommand Line InterfaceThere's a CLI for testing purposes.aiomysensors--debugserial-gateway-p/dev/ttyACM0CreditsThis package was created withCookiecutterand thebrowniebroke/cookiecutter-pypackageproject template.
Package: aiomysimple
AioMySimpleAioMySimple is a simpler interface for AioMySQLimportaiomysimpledb=aiomysimple.Database(host="127.0.0.1",port=3306,user="root",password="",db="test_pymysql")my_table=db.get_table("my_table","id")asyncforrowinawaitmy_table.search():print(row["my_key"])awaitrow.update(my_key=row["my_key"]+1)result=awaitmy_table.search()print((awaitresult[3])["my_key"])
Package: aiomysql-core
Aiomysql-CoreSimple framework for aiomysqlIntroducesimple package, easy to useaiomysqlDocumentclick meInstallationpip install aiomysql-coreSimple usesimportasyncioimportaiomysqlfromaiomysql_coreimportAioMysqlCoreasyncdeftest_example(loop):pool=awaitaiomysql.create_pool(host='',port=3306,user='',password='',db='',loop=loop)core=AioMysqlCore(pool=pool)rows=awaitcore.query('select * from users where uid=%s',113)print(rows)rows=awaitcore.gener('select * from users limit 100')asyncforrowinrows:print(row)row=awaitcore.get('select * from users where uid=%(uid)s',{'uid':113})print(row)rowcount=awaitcore.execute_rowcount('select * from users where uid=%(uid)s',{'uid':113})print(rowcount)pool.close()awaitpool.wait_closed()loop=asyncio.get_event_loop()loop.run_until_complete(test_example(loop))Simple SQLAlchemy usesimportasynciofromaiomysql.saimportcreate_enginefromaiomysql_coreimportAioMysqlAlchemyCorefromsqlalchemyimportColumn,Integer,String,MetaData,Tablemetadata=MetaData()Test=Table('test',metadata,Column('id',Integer,primary_key=True),Column('content',String(255),server_default=""))asyncdeftest_example(loop):config={'user':'','password':'','db':'','host':'','port':3306,'autocommit':True,'charset':'utf8mb4'}engine=awaitcreate_engine(loop=loop,**config)core=AioMysqlAlchemyCore(engine=engine)# insertdoc={'content':'insert'}clause=Test.insert().values(**doc)rowcount=awaitcore.execute_rowcount(clause)print(rowcount)# searchclause=Test.select().where(Test.c.id==1).limit(1)row=awaitcore.get(clause)print(row.id,row.content)clause=Test.select().where(Test.c.id>1)rows=awaitcore.query(clause)asyncforrowinrows:print(row.id,row.content)# updatedoc={'content':'update'}clause=Test.update().values(**doc).where(Test.c.id==1)rowcount=awaitcore.execute_rowcount(clause)print(rowcount)# deleteclause=Test.delete().where(Test.c.id==1)rowcount=awaitcore.execute_rowcount(clause)print(rowcount)awaitengine.wait_closed()loop=asyncio.get_event_loop()loop.run_until_complete(test_example(loop))
Package: aioN26
# aioN26
Unofficial Asynchronous N26-bank API implementationbased onhttps://app.swaggerhub.com/apis/Rots/N26/0.2#/transactions/get_smrt_transactionsI will document this better in the future, but here is a working example:import asyncio
from aioN26.api import Api

from pprint import pprint
import logging

import os
from dotenv import load_dotenv    # pip install python-dotenv

# We load local environment variables from file MYSECRET.env
# The file format is as follows:

# ------------MYSECRET.env-------------
# USERNAME=john.doe@mail.com
# PASSWORD=mysecretpassword
# DEVICE_TOKEN=yourgeneratedtoken
# -------------------------------------

# to generate the DEVICE_TOKEN, run this in a python3 console:
# >>> import uuid ; print(uuid.uuid4())
# and paste the result in the file

load_dotenv('MYSECRET.env')    # directory/file containing the environment variables

logging.basicConfig(level=logging.DEBUG)


async def main():
    async with Api(username=os.getenv('USERNAME'), password=os.getenv('PASSWORD'),
                   device_token=os.getenv('DEVICE_TOKEN')) as api:

        print(api.get_device_token())

        print('\nget_me = \\')
        pprint(await api.get_me())

        print('\nget_me_statuses = \\')
        pprint(await api.get_me_statuses())

        print('\nget_addresses = \\')
        pprint(await api.get_addresses())

        print('\nget_barzahlen_check = \\')
        pprint(await api.get_barzahlen_check())

        print('\nget_spaces = \\')
        pprint(await api.get_spaces())

        print('\nget_accounts = \\')
        pprint(await api.get_accounts())

        print('\nget_settings_account_limits = \\')
        pprint(await api.get_settings_account_limits())

        print('\nset_settings_account_limits = \\')
        pprint(await api.set_settings_account_limits(500, 3000))

        print('\nget_smrt_categories = \\')
        pprint(await api.get_smrt_categories())

        print('\nget_smrt_transactions = \\')
        transactions = await api.get_smrt_transactions(from_time=1636030755256, to_time=1636030755256)
        pprint(transactions)
        print('TOTAL', len(transactions))

asyncio.run(main())
Package: aio-nano
aio-nanoOverviewThis library contains an asynchronous python RPC client for Nano nodes, allowing you to more easily develop on the Nano network with fully type annnotated methods and responses.InstallationPIPpip install aio-nanoPoetrypoetry add aio-nanoExample Async HTTP RPC Callfromaio_nanoimportClientimportasyncioasyncdefmain():api_key=...client=Client('https://mynano.ninja/api/node',{'Authorization':api_key})supply=awaitclient.available_supply()print(supply)asyncio.run(main())Example Async WebSocket RPC Subscriptionimportasynciofromtimeimporttimefromaio_nanoimportWSClientasyncdefmain():ws=awaitWSClient("ws://localhost:7078").connect()start=time()*1000awaitws.subscribe("confirmation",lambdax:print(x),ack=True)print(f"Acked in{time()*1000-start}ms")awaitasyncio.Future()asyncio.run(main())
Package: aionanoleaf
aioNanoleaf packageAn async Python wrapper for the Nanoleaf API.InstallationpipinstallaionanoleafUsageImportfromaionanoleafimportNanoleafCreate aaiohttp.ClientSessionto make requestsfromaiohttpimportClientSessionsession=ClientSession()Create aNanoleafinstancefromaionanoleafimportNanoleaflight=Nanoleaf(session,"192.168.0.100")ExamplefromaiohttpimportClientSessionfromasyncioimportrunimportaionanoleafasyncdefmain():asyncwithClientSession()assession:nanoleaf=aionanoleaf.Nanoleaf(session,"192.168.0.73")try:awaitnanoleaf.authorize()exceptaionanoleaf.Unauthorizedasex:print("Not authorizing new tokens:",ex)returnawaitnanoleaf.turn_on()awaitnanoleaf.get_info()print("Brightness:",nanoleaf.brightness)awaitnanoleaf.deauthorize()run(main())
Package: aionap
aionap is aPythonasyncio enabled REST client. It uses a similar API likeslumberand copies shameless other parts of it.Feel free to contribute via pull requests, issues or email messages.QuickStartInstall aionap:$ pip install aionapInstall Optional Requirement:pip install pyyamlUse it!UsageGet an API object and fetch a url/resource (e.g.https://demo.api-platform.com/books)importaionapasyncwithaionap.API('https://demo.api-platform.com')asapiresponse=awaitapi.books.get()For more see thedocumenation, thetest/test_demo_api.pyfile or theexampledirectory.Installationaionap is available via PyPI, just install it as usual.$pipinstallaionapaionaprequires Python >= 3.6.[OPTIONAL]PyYaml (Required for the yaml serializer):$pipinstallpyyamlFeaturesBasic Auth supportJSON, YAML serializersGET, POST, PUT, PATCH, DELETE of resourcesGood test coverageTODOOAuth supportReadthedocs API documentation (SSL_CERT_FILE)CompatibilityPython >= 3.6LicenceBSD 2-Clause LicenseAuthors and ContributorsChristian Assing(Main author)
Package: aionasa
aionasaAn async python wrapper for NASA open APIs. (api.nasa.gov)DisclaimerThis module is still in the development/testing phase.
Bugs are still being worked out and breaking changes are common.Current Progress: 5/17 APIsAPOD: NASA Astronomy Picture of the DayAPI:completeCLI:completeDocumentation:completeInSight: Mars Weather DataAPI:completeDocumentation:completeEPIC: Earth Polychromatic Imaging CameraAPI:completeDocumentation:completeAsteroids-NeoWs: Near Earth Object Web ServiceAPI:completeDocumentation:completeExoplanet: NASA Exoplanet DatabaseAPI:completeDocumentation:completeInstallingaionasa can be installed from pypi with the command:# Linuxpython3-mpipinstall-Uaionasa# Windowspython-mpipinstall-UaionasaTo install the development version of the library directly from source:$gitclonehttps://github.com/nwunderly/aionasa
$cdaionasa
$python3-mpipinstall-U.QuickstartWe'll be using IPython because it supportsawaitexpressions directly from the console.$pipinstallaionasaipython
$ipythonfromaionasaimportAPOD,InSightasyncwithAPOD()asapod:picture=awaitapod.get()picture.url# this will be the most recent APOD image URL.asyncwithInSight()asinsight:data=awaitinsight.get()data# this will be a dict containing the JSON data returned by the API.
Package: aio-nasa-tle-loader
SpaceTrackApi clientSmall async wrapper fornasa-tle-loaderpackageRequirementsaiohttp >= 2.0.7nasa-tle-loader >= 1.0.0Installingpip install aio-nasa-tle-loaderGetting startedTo retrieve something from Space-Track:# -*- coding: utf-8 -*-importasyncioimportjsonfromaio_nasa_tle_loaderimportAsyncNasaTLELoaderasyncdefmain(loop):asyncwithAsyncNasaTLELoader(loop=loop)asloader:# Getting list `nasa_tle_loader.TLE`(namedtuple like) objectstle_list=awaitloader()# Print result as JSONprint(json.dumps([tle.as_dict()fortleintle_list[:3]],indent=2))if__name__=='__main__':loop=asyncio.get_event_loop()loop.run_until_complete(main(loop))Result:[
  {
    "EPOCH": "2017-05-17 13:16:58",
    "EPOCH_MICROSECONDS": "124064",
    "NORAD_CAT_ID": "25544",
    "TLE_LINE0": "ISS",
    "TLE_LINE1": "1 25544U 98067A   17137.55345051  .00016717  00000-0  10270-3 0  9004",
    "TLE_LINE2": "2 25544  51.6389 191.0057 0005051 169.7469 190.3787 15.54030000 16987"
  },
  {
    "EPOCH": "2017-05-17 22:32:35",
    "EPOCH_MICROSECONDS": "151072",
    "NORAD_CAT_ID": "25544",
    "TLE_LINE0": "ISS",
    "TLE_LINE1": "1 25544U 98067A   17137.93929573  .00016717  00000-0  10270-3 0  9014",
    "TLE_LINE2": "2 25544  51.6398 189.0848 0005258 166.2909 193.8387 15.53887043 17040"
  },
  {
    "EPOCH": "2017-05-18 01:37:47",
    "EPOCH_MICROSECONDS": "963136",
    "NORAD_CAT_ID": "25544",
    "TLE_LINE0": "ISS",
    "TLE_LINE1": "1 25544U 98067A   17138.06791624  .00016717  00000-0  10270-3 0  9024",
    "TLE_LINE2": "2 25544  51.6394 188.4430 0005111 170.0057 190.1198 15.53888284 17061"
  }
]Source codeThe latest developer version is available in a github repository:https://github.com/nkoshell/aio-nasa-tle-loader
Package: aiondata
📊 AionDataAionData is a common data access layer designed for AI-driven drug discovery software. It provides a unified interface to access diverse biochemical databases.InstallationTo install AionData, ensure you have Python 3.10 or newer installed on your system. You can install AionData via pip:pipinstallaiondataDatasetsAionData provides access to the following datasets:BindingDB: A public, web-accessible database of measured binding affinities, focusing chiefly on the interactions of proteins considered to be drug-targets with small, drug-like molecules.MoleculeNet: An extensive collection of datasets curated to support and benchmark the development of machine learning models in the realm of drug discovery and chemical informatics. Covers a broad spectrum of molecular data including quantum mechanical properties, physical chemistry, biophysics, and physiological effects.Tox21: Features qualitative toxicity measurements for 12,000 compounds across 12 targets, used for toxicity prediction.ESOL: Contains water solubility data for 1,128 compounds, aiding in solubility prediction models.FreeSolv: Provides experimental and calculated hydration free energy for small molecules, crucial for understanding solvation.Lipophilicity: Includes experimental measurements of octanol/water distribution coefficients (logD) for 4,200 compounds.QM7: A dataset of 7,165 molecules with quantum mechanical properties computed using density functional theory (DFT).QM8: Features electronic spectra and excited state energies of over 20,000 small molecules computed with TD-DFT.QM9: Offers geometric, energetic, electronic, and thermodynamic properties of ~134k molecules computed with DFT.MUV: Datasets designed for the validation of virtual screening techniques, with about 93,000 compounds.HIV: Contains data on the ability of compounds to inhibit HIV replication, for binary classification tasks.BACE: Includes quantitative binding results for inhibitors of human beta-secretase 1, with both classification and regression tasks.BBBP: Features compounds with information on permeability properties across the Blood-Brain Barrier.SIDER: Contains information on marketed medicines and their recorded adverse drug reactions, for side effects prediction.ClinTox: Compares drugs approved by the FDA and those that failed clinical trials for toxicity reasons, for binary classification and toxicity prediction.LicenseAionData is licensed under the Apache License. See the LICENSE file for more details.
Package: aionefit
Python asyncio library for (some) Bosch thermostatsaionefit is a Python library to control some Bosch thermostats using the Python asycio framework. This is done with theSlixmpplibrary.As there is no known way to talk directly to the thermostat, all communication has to be routed via cloud servers at Bosch.Original codeThis software is based on code of the following projects:https://github.com/robertklep/nefit-easy-clienthttps://github.com/patvdleer/nefit-client-pythonSupported hardwaresourceNefit Easy (Netherlands)Junkers Control CT100 (Belgium, Germany)Buderus Logamatic TC100 (Belgium)E.L.M. Touch (France)Worcester Wave (UK)Bosch Control CT‑100 (Other)
Package: aionefit-updated
Python asyncio library for (some) Bosch thermostatsaionefit is a Python library to control some Bosch thermostats using the Python asycio framework. This is done with theSlixmpplibrary.As there is no known way to talk directly to the thermostat, all communication has to be routed via cloud servers at Bosch.Original codeThis software is based on code of the following projects:https://github.com/robertklep/nefit-easy-clienthttps://github.com/patvdleer/nefit-client-pythonSupported hardwaresourceNefit Easy (Netherlands)Junkers Control CT100 (Belgium, Germany)Buderus Logamatic TC100 (Belgium)E.L.M. Touch (France)Worcester Wave (UK)Bosch Control CT‑100 (Other)
Package: aioneo4j
info:asyncio client for neo4jInstallationpipinstallaioneo4jUsageimportasynciofromaioneo4jimportNeo4jasyncdefgo():asyncwithNeo4j('http://neo4j:neo4j@127.0.0.1:7474/')asneo4j:data=awaitneo4j.data()assertbool(data)loop=asyncio.get_event_loop()loop.run_until_complete(go())loop.close()
Package: aionet
Asynchronous multi-vendor library for interacting with network devicesthis is a fork from netdev, with code refactor and new features added.Requires:asyncioAsyncSSHPython >=3.5pyYAMLasyncsshSupports:Cisco IOSCisco IOS XECisco IOS XRCisco ASACisco NX-OSHP ComwareFujitsu Blade SwitchesMikrotik RouterOSArista EOSJuniper JunOSAruba AOS 6.XAruba AOS 8.XTerminalFeatures:SSHTelnetTextFSMExamples:Example of interacting with Cisco IOS devices:importasyncioimportaionetasyncdeftask(device):asyncwithaionet.ConnectionHandler(**device)asconn:out=awaitconn.send_command("show ver")print(out)commands=["interface vlan2","no shut"]out=awaitconn.send_config_set(commands)asyncdefrun():dev1={'username':'user','password':'pass','device_type':'cisco_ios','ip':'ip address',}dev2={'username':'user','password':'pass','device_type':'cisco_ios','ip':'ip address',}devices=[dev1,dev2]tasks=[task(dev)fordevindevices]awaitasyncio.wait(tasks)loop=asyncio.get_event_loop()loop.run_until_complete(run())
Package: aionetbox
AIO NetboxAn asyncio netbox library that conforms to any running netbox via it's OpenAPI specInstallationAIONetbox is distributed as a library intended to be included in other asyncio python projects. It has been developed on python 3.6+ though 3.8 is recommended.pip install aionetboxUsagefrom aionetbox import AIONetbox

netbox = AIONetbox.from_openapi(
    url='http://localhost:8000',
    api_key='0123abcd'
)

sites = await netbox.dcim.dcim_sites_list()
my_site = await netbox.dcim.dcim_sites_read(id=2)

custom_field_sort = await netbox.dcim.dcim_regions_list(cf_sf_id='identifier')Each module and method map to the swagger definition for netbox (/api/docs)
Package: aio-net-events
aio-net-eventsaio-net-eventsis a Python library that provides asynchronous generators
yielding events when the network configuration of the machine changes.
Currently only network interface additions / removals and IP address additions /
removals are supported; more events may be added later.Supports Windows, Linux and macOS at the moment.Requires Python >= 3.8.Works withasyncioandtrio.InstallationUse the package managerpipto installaio-net-events.pipinstallaio-net-eventsUsageContributingPull requests are welcome. For major changes, please open an issue first to
discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT