Saravanan666/pypi-org huggingface dataset:
Package: aioimport
aioimportAsynchronous module import for asyncioGetting StartedInstallingInstall fromPyPIusing:pip install aioimportThe problemSome naughty modules have long running operations during importNaive solutionFirst thing that comes to mind is make import local:asyncdefmy_work()->None:importnaughty# will block event loopIt reduces time your program takes to start (or library to import),
but it is still blocking your event loop.Usageimportaioimportasyncdefmy_work()->None:awaitaioimport.import_module("naughty")# will asynchronously import moduleimportnaughty# will be instantaneous since `naughty` is already in `sys.modules`awaitaioimport.reload(naughty)# and you can asynchronously reload modules tooHow it worksModule import is done in asyncio default executor.Be aware of the fact that GIL still exists and technically import is done concurrently rather than in parallel with your code.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details
Package: aioinflux
Asynchronous Python client forInfluxDB. Built on top ofaiohttpandasyncio.
Aioinflux is an alternative to the official InfluxDB Python client.Aioinflux supports interacting with InfluxDB in a non-blocking way by usingaiohttp.
It also supports writing and querying ofPandasdataframes,
among other handy functionality.Please refer to thedocumentationfor more details.InstallationPython 3.6+ is required.
You also need to have access to a running instance of InfluxDB.pipinstallaioinfluxQuick startThis sums most of what you can do withaioinflux:importasynciofromaioinfluximportInfluxDBClientpoint={'time':'2009-11-10T23:00:00Z','measurement':'cpu_load_short','tags':{'host':'server01','region':'us-west'},'fields':{'value':0.64}}asyncdefmain():asyncwithInfluxDBClient(db='testdb')asclient:awaitclient.create_database(db='testdb')awaitclient.write(point)resp=awaitclient.query('SELECT value FROM cpu_load_short')print(resp)asyncio.get_event_loop().run_until_complete(main())See thedocumentationfor more detailed usage.
Package: aioinflux3
aio-influxinfluxdb python client working with asyncioInstallpip install aioinflux3Initialize asynchronous clientfrom aioinflux3 import InfluxClient, Measurement, Query, Field

async with InfluxClient(host=..., port=..., org=..., token=...) as client:
    # write code hereWrite dataasync with InfluxClient(host=..., port=..., org=..., token=...) as client:
    await client.write(Measurement.new('measurement',
                               timestamp, 
                               tag=[Field(key=tag key,
                                          val=tag value), ],
                               fields=[
                                   Field(key=filed key,
                                         val=field value),
                               ]
                        )
                      )Make Queryasync with InfluxClient(host=..., port=..., org=..., token=...) as client:
    query = Query(bucket name, measurement=measurement name)
              .range(start='-4h', end='-1s')
              .filter('_field name', tag name= tag value)
              .window(every='5s', fn='func name') # func name in next list
              .do_yield(name='func name') # name if optional
    resp = await client.query(query) # return json table
    resp = await client.query(query, numpy=True) # return a numpy Structured Arrayfunc list:meanmedianmaxminsumderivativedistinctcountincreaseskewspreadstddevfirstlastuniquesortnonnegative derivative1NoticeThis project started for own useage. My goal is make it simple and easy to use, it's not full functional for InfluxDB v2 API. If you like it, Pls star, and tell me yourneeds in issuse, I will try my best to make it happen.
Package: aioinfluxdb
aioinfluxdbThe Python client for InfluxDB v2 supports asyncio.This is early-stage projectWhy aioinfluxdb?The official clientdoes not supports asyncio that can get significant
performance. andaioinfluxdoes not supports InfluxDB v2.Feature tableFeatureSub category✅ / ⚠ / 🚧QueryQuery Data✅QueryAnalyzer Flux Query🚧QueryGenerate AST from Query🚧QueryRetrieve query suggestions🚧QueryRetrieve query suggestionsfor a branching suggestion🚧Write✅Buckets⚠Dashboards🚧Tasks🚧Resources🚧Authorizations🚧Organizations⚠Users🚧Health🚧Ping✅Ready🚧Routes🚧Backup🚧Cells🚧Checks🚧DBRPs🚧Delete🚧Labels🚧NotificationEndpoints🚧NotificationRules🚧Restore🚧Rules🚧Scraper Targets🚧Secrets🚧Setup🚧Signin🚧Signout🚧Sources🚧Telegraf Plugins🚧Telegrafs🚧Templates🚧Variables🚧Views🚧This project borrows some de/serialization code frominfluxdb-client.
Package: aioinsta
aioINSTAStill in developmentAsynchronous wrapper of instagram PRIVATE APIimportasynciofromaioinstaimportClientsettings={"your_settings":"xxxx"}client=Client()asyncdefmain():awaitclient.login("username","password")data=awaitclient.media_info(client.media_pk_from_url("https://www.instagram.com/p/CrfF1nhslH4"))print(data)asyncio.run(main())
Package: aioinstagrapi
Fast and effective asynchronous Instagram Private API wrapper (public+private requests and challenge resolver).Uses the most recent version of the API from Instagram.Async wrapper aroundhttps://githib.com/adw0rd/instagrapiFeatures:Performs Public API (web, anonymous) or Private API (mobile app, authorized)
requests depending on the situation (to avoid Instagram limits)Challenge Resolver have Email (as well as recipes for automating receive a code from email) and SMS handlersSupport upload a Photo, Video, IGTV, Clips (Reels), Albums and StoriesSupport work with User, Media, Insights, Collections, Location (Place), Hashtag and Direct objectsLike, Follow, Edit account (Bio) and much more elseInsights by account, posts and storiesBuild stories with custom background, font animation, swipe up link and mention usersIn the next release, account registration and captcha passing will appear
Package: aiointeractions
An async Discord HTTP Interactions wrapper fordiscord.pybuilt withaiohttp.Documentationhttps://aiointeractions.readthedocs.io/Installingaiointeractionsrequires Python 3.8 or newer.pip install aiointeractionsExampleimportasyncioimportdiscordimportaiointeractionsintents=discord.Intents.none()# intents are not required because there is no gateway connectionclient=discord.Client(intents=intents)tree=discord.app_commands.CommandTree(client)app=aiointeractions.InteractionsApp(client)discord.utils.setup_logging(root=True)@tree.command()asyncdefping(interaction:discord.Interaction)->None:awaitinteraction.response.send_message('Pong!')app.run('bot token')Fork SupportWhile some forks may be compatible, discord.py forks will not be supported.
Package: aio-iotccsdk
Python SDK for AI Vision Developer KitThis library allows developer to control theQualcomm Visual Intelligence Platformfor hardware acceleration fo AI models to deliver superior inferencing performance.The library enables developers to easily combine the Vision AI DevKit withAzure IoT Edgeto deploy vision ML models and custom business logic from the cloud to the edge.UsageThe main class for controlling the camera is the CameraClient:fromiotccsdkimportCameraClientcamera_client=CameraClient.connect(username="admin",password="admin",ip_address=<cameraipaddress>)camera_client.configure_preview(resolution="1080P",encode="AVC/H.264",bitrate="1.5Mbps",display_out=1)camera_client.set_preview_state("on")rtsp_stream_address=camera_client.preview_urlFor more complete code examples see the samples folder in the project GitHub repositoryhttps://github.com/microsoft/vision-ai-developer-kit.Release History0.1.4 (2019-06-19)Update project metadata and readme0.1.0 (2019-06-19)Project creation
Package: aio-ipfabric
Python Asyncio Client for IP FabricThis package contains a Python 3.8+ asyncio client for use wih the IP Fabric product.About IP Fabric:https://ipfabric.io/About IP Fabric API:https://docs.ipfabric.io/api/Installating aio-ipfabric and supported versionsaio-ipfabric is available onPyPI:pipinstallaio-ipfabricDirect installationpipinstallgit+https://github.com/jeremyschulman/aio-ipfabric@master#egg=aio-ipfabricRequests officially supports Python 3.8+.Quick StartfromaioipfabricimportIPFabricClientasyncdefdemo_1_devices_list():"""Example code that uses IPFabricClient without contextmanager"""# create a client using environment variables (see next section)ipf=IPFabricClient()# alternatively create instance with parameters# ipf = IPFabricClient(base_url='https://myipfserver.com', username='admin', password='admin12345')# ipf = IPFabricClient(base_url='https://myipfserver.com', token='TOKENFROMIPF')# login to IP Fabric systemawaitipf.login()# fetch the complete device inventorydevice_list=awaitipf.fetch_devices()# close asyncio connection, otherwise you will see a warning.awaitipf.logout()returndevice_listasyncdefdemo_2_devices_list():"""Example code that uses IPFabricClient as contextmanager"""# create a client using environment variables (see next section)asyncwithIPFabricClient()asipf:returnawaitipf.fetch_devices()Environment VariablesThe following environment variable can be used so that you do no need to
provide them in your program:IPF_ADDR- IP Fabric server URL, for example "https://my-ipfabric-server.com/"IPF_USERNAME- Login usernameIPF_PASSWORD- Login passwordIPF_TOKEN- A persistent API tokenYou can use either the login credentials or the token to login.If you prefer not to use environment variables, the call toIPFabricClient()accepts
parameters; refer to thehelp(IPFabricClient)for details.DocumentationSee thedocsdirectory.
Package: aioipfs
info:AsynchronousIPFSclient libraryaioipfsis a python3 library providing an asynchronous API forIPFS.
Supported python versions:3.6,3.7,3.8,3.9,3.10,3.11,3.12.This library supports theRPC API specificationsforkuboversion0.26.0. Unit tests are run against
most major go-ipfs releases and allkuboreleases, see theCIsection below.Seethe documentation here.InstallationpipinstallaioipfsSupport for CAR (Content-Addressable Archives) decoding (with theipfs-car-decoder package)
can be enabled with thecarextra:pipinstall'aioipfs[car]'By default thejsonmodule from the standard Python library is used
to decode JSON messages, butorjsonwill be used if it is installed:pipinstall'aioipfs[orjson]'UsageClient instantiationThe recommended way to specify the kubo node’s RPC API address is
to pass amultiaddr.client=aioipfs.AsyncIPFS(maddr='/ip4/127.0.0.1/tcp/5001')client=aioipfs.AsyncIPFS(maddr='/dns4/localhost/tcp/5001')You can also pass amultiaddr.Multiaddrinstance.frommultiaddrimportMultiaddrclient=aioipfs.AsyncIPFS(maddr=Multiaddr('/ip4/127.0.0.1/tcp/5001'))Otherwise just passhostandportseparately:client=aioipfs.AsyncIPFS(host='localhost',port=5001)client=aioipfs.AsyncIPFS(host='::1',port=5201)Get an IPFS resourceimportsysimportasyncioimportaioipfsasyncdefget(cid:str):client=aioipfs.AsyncIPFS()awaitclient.get(cid,dstdir='.')awaitclient.close()loop=asyncio.get_event_loop()loop.run_until_complete(get(sys.argv[1]))Add some filesThis example will import all files and directories specified on the command
line. Note that theaddAPI function is an asynchronous generator and
therefore should be used with theasync forsyntax.importsysimportasyncioimportaioipfsasyncdefadd_files(files:list):client=aioipfs.AsyncIPFS()asyncforadded_fileinclient.add(*files,recursive=True):print('Imported file{0}, CID:{1}'.format(added_file['Name'],added_file['Hash']))awaitclient.close()loop=asyncio.get_event_loop()loop.run_until_complete(add_files(sys.argv[1:]))You can also use the async list generator syntax:cids=[entry['Hash']asyncforentryinclient.add(dir_path)]Pubsub serviceasyncdefpubsub_serve(topic:str):asyncwithaioipfs.AsyncIPFS()ascli:asyncformessageincli.pubsub.sub(topic):print('Received message from',message['from'])awaitcli.pubsub.pub(topic,message['data'])Dialing a P2P serviceasyncwithaioipfs.AsyncIPFS()asclient:asyncwithclient.p2p.dial_service(peer_id,'/x/echo')asdial:print(f'Dial host:{dial.maddr_host}, port:{dial.maddr_port}')# Connect to the service now....CIThe Gitlab CI workflow runs unit tests against the following
go-ipfs/kubo releases (go herefor the CI jobs overview).go-ipfs >=0.11.0,<=0.13.0kubo >=0.14.0,<=0.26.0FeaturesAsync file writing on get operationsTheaiofileslibrary is used to asynchronously write data retrieved from
the IPFS daemon when using the/api/v0/getAPI call, to avoid blocking the
event loop. TAR extraction is done in asyncio’s threadpool.RequirementsPython >= 3.6, <= 3.11aiohttpaiofilespy-multibaseyarlLicenseaioipfsis offered under the GNU Lesser GPL3 (LGPL3) license.
Package: aioipfs-api
Async IPFS API ClientDocumentation can be found ataioipfs-api.readthedocs.org.Installationpip install aioipfs-apiUsageThis assumes you have a working familiarity withasyncio.importasynciofromaioipfs_api.clientimportClientasyncdefmain():asyncwithClient()asclient:# print the readmeasyncwithclient.cat("QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG/readme")asf:print(awaitf.text())# add a directoryprint(awaitclient.add('/some/dir/path'))loop=asyncio.get_event_loop()loop.run_until_complete(main())LoggingThis library uses the standardPython logging library.  To see debut output printed to STDOUT, for instance, use:importlogginglog=logging.getLogger('aioipfs_api')log.setLevel(logging.DEBUG)log.addHandler(logging.StreamHandler())Running TestsTo run tests:pip install -r dev-requirements.txt
python -m unittest
Package: aioircd
aioircdA minimalist python asynchronous IRC server built on top ofTrio.Installation and UsageDownload and install the latest stable version using pip.
Windows users might replacepython3bypy.python3 -m pip install aioircdThen run the server:HOST=0.0.0.0 LOGLEVEL=INFO python3 -m aioircdThe configuration is done via environment variables, see--help:optional arguments:
  -h, --help     show this help message and exit
  -V, --version  show program's version number and exit

environment variables:
  HOST           public domain name (default: julien-UX410UAR)
  ADDR           ip address to bind (default: 127.0.1.1)
  PORT           port to bind (default: 6667)
  PASS           server password (default: )
  TIMEOUT        kick inactive users after x seconds (default: 60)
  PING_TIMEOUT   PING inactive users x seconds before timeout (default: 5)
  LOGLEVEL       logging verbosity (default: WARNING)ScopeWe try to both keep only implement the most important commands and to
make sure all modern IRC clients are working. If you are having
troubles using aioircd with your client feel free to open an issue.Stuff we don't plan to support: server connections, user modes, channel
modes.
Package: aioiregul
aioiregulAsynchronous library to get data from Iregul systemsThis library is under developmentRequires Python 3 and uses asyncio, aiohttp and BeautifulSoup4.importaioiregulimportaiohttpimportasyncioasyncdefmain():opt=aioiregul.ConnectionOptions(username='User',password='Pass')dev=aioiregul.Device(opt)res=awaitdev.collect()print(res)loop=asyncio.get_event_loop()loop.run_until_complete(main())
Package: aioisotp
This package implementsISO-TPover CAN as anasynciotransport layer,
enabling simultaneous receiving and transmitting messages with any number
of connections.Raw CAN communication usespython-canwhich offers compatibility for many
different CAN interfaces and operating systems.If SocketCANISO-TP moduleis loaded and Python 3.7+ is used, the transport is
delegated to the kernel if possible for better timing performance.
Use the ‘socketcan’ interface. If unsuccessful, raw CAN will be used as fallback.The isotpserver fromcan-utilscan also be used to bridge a SocketCAN ISO-TP
connection over TCP/IP.
Use the ‘isotpserver’ interface and ‘host:port’ as channel.Why asynchronous?Asynchronous programming simplifies some possible use-cases:Full duplex receiving and transmitting on a single connection.Communicate on multiple connections simultaneously.Functional addressing where one request is sent out and all nodes respond,
then processing the responses as they arrive.Implementing or simulating multiple servers.No threads need to be handled with all the locking mechanisms required by it.InstallationInstall from PyPI:$ pip install aioisotp==0.1.1DocumentationA basic documentation can be built using Sphinx:$ python setup.py build_sphinxQuick startHere is an example of an echo server implemented using a callback based
protocol and a client implemented as sequencial reader and writer streams.importasyncioimportaioisotpclassEchoServer(asyncio.Protocol):defconnection_made(self,transport):self.transport=transportdefdata_received(self,data):# Echo back the same dataself.transport.write(data)asyncdefmain():network=aioisotp.ISOTPNetwork('vcan0',interface='virtual',receive_own_messages=True)withnetwork.open():# A server that uses a protocoltransport,protocol=awaitnetwork.create_connection(EchoServer,0x1CDADCF9,0x1CDAF9DC)# A client that uses streamsreader,writer=awaitnetwork.open_connection(0x1CDAF9DC,0x1CDADCF9)writer.write(b'Hello world!')response=awaitreader.read(4095)assertresponse==b'Hello world!'loop=asyncio.get_event_loop()loop.run_until_complete(main())UDSThis package is meant to enable the use of other protocols that require
ISO-TP. One of the most common is UDS. A third party library likeudsoncanorpyvitcan be used to encode and decode payloads.importaioisotpimportudsoncan...reader,writer=awaitnetwork.open_connection(0x1CDAF9DC,0x1CDADCF9)# Construct and send requestrequest=udsoncan.Request(udsoncan.services.ReadDataByIdentifier,data=b'\xF1\x90')writer.write(request.get_payload())# Wait for response and decode the payloadpayload=awaitreader.read(4095)response=udsoncan.Response.from_payload(payload)print(response)print(response.data)
Package: aioitertools
aioitertoolsImplementation of itertools, builtins, and more for AsyncIO and mixed-type iterables.Installaioitertools requires Python 3.6 or newer.
You can install it from PyPI:$ pip install aioitertoolsUsageaioitertools shadows the standard library whenever possible to provide
asynchronous version of the modules and functions you already know.  It's
fully compatible with standard iterators and async iterators alike, giving
you one unified, familiar interface for interacting with iterable objects:fromaioitertoolsimportiter,next,map,zipsomething=iter(...)first_item=awaitnext(something)asyncforiteminiter(something):...asyncdeffetch(url):response=awaitaiohttp.request(...)returnresponse.jsonasyncforvalueinmap(fetch,MANY_URLS):...asyncfora,binzip(something,something_else):...aioitertools emulates the entireitertoolsmodule, offering the same
function signatures, but as async generators.  All functions support
standard iterables and async iterables alike, and can take functions or
coroutines:fromaioitertoolsimportchain,isliceasyncdefgenerator1(...):yield...asyncdefgenerator2(...):yield...asyncforvalueinchain(generator1(),generator2()):...asyncforvalueinislice(generator1(),2,None,2):...Seebuiltins.py,itertools.py, andmore_itertools.pyfor full
documentation of functions and abilities.Licenseaioitertools is copyrightAmethyst 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: aioja
aiojaAsync version of Jinja2.This library contains a modification of the Jinja2 library.
In addition to Jinja's built-inrender_async, i've added:asyncFileSystemLoader(viaaiofiles)async bytecode cache (aioredisandaiocachesupported)async version of theEnvironment.compile_templatesmethodInstallpip install aiojaQuick Startfromaioja.environmentimportEnvironmentfromaioja.loadersimportFileSystemLoaderfromaioja.bccache.aiocacheimportAioCacheBytecodeCacheenv=Environment(loader=FileSystemLoader('templates'),# ...# bytecode_cache=AioCacheBytecodeCache()# ...)template=awaitenv.get_template('index.html')content=awaittemplate.render_async({'page_id':123})
Package: aiojarm
aiojarmAsync version ofJARM.InstallationpipinstallaiojarmUsageimportasyncioimportaiojarmloop=asyncio.get_event_loop()fingerprints=loop.run_until_complete(asyncio.gather(aiojarm.scan("www.salesforce.com"),aiojarm.scan("www.google.com"),aiojarm.scan("www.facebook.com"),aiojarm.scan("github.com"),))print(fingerprints)# [#     (#         "www.salesforce.com",#         443,#         "23.42.156.194",#         "2ad2ad0002ad2ad00042d42d00000069d641f34fe76acdc05c40262f8815e5",#     ),#     (#         "www.google.com",#         443,#         "172.217.25.228",#         "27d40d40d29d40d1dc42d43d00041d4689ee210389f4f6b4b5b1b93f92252d",#     ),#     (#         "www.facebook.com",#         443,#         "31.13.82.36",#         "27d27d27d29d27d1dc41d43d00041d741011a7be03d7498e0df05581db08a9",#     ),#     (#         "github.com",#         443,#         "52.192.72.89",#         "29d29d00029d29d00041d41d0000008aec5bb03750a1d7eddfa29fb2d1deea",#     ),# ]CLI usage$aiojarm--help
Usage:aiojarm[OPTIONS]HOSTNAMES...

Arguments:HOSTNAMES...IPs/domainsorafilewhichcontainsalistofIPs/domainsperline[required]Options:--portINTEGER[default:443]--max-at-onceINTEGER[default:8]--install-completionInstallcompletionforthecurrentshell.--show-completionShowcompletionforthecurrentshell,tocopyitorcustomizetheinstallation.--helpShowthismessageandexit.

$aiojarm1.1.1.11.1.1.1,443,1.1.1.1,27d3ed3ed0003ed1dc42d43d00041d6183ff1bfae51ebd88d70384363d525c

$aiojarmgoogle.com.uagoogle.gr
google.com.ua,443,172.217.25.195,27d40d40d29d40d1dc42d43d00041d4689ee210389f4f6b4b5b1b93f92252d
google.gr,443,216.58.220.131,27d40d40d29d40d1dc42d43d00041d4689ee210389f4f6b4b5b1b93f92252d# or you can input hostnames via a file$aiojarmlist.txtLicenseJARM is created by Salesforce's JARM team and it is licensed with 3-Clause "New" or "Revised" License.https://github.com/salesforce/jarm/blob/master/LICENSE.txt
Package: aiojenkins
Asynchronous python package of Jenkins API endpoints based on aiohttp.Also pay attention to brand new package with same API set but with sync and async interfaces:https://github.com/pbelskiy/ujenkinsInstallationpip3installaiojenkinsUsageStart new build:importasyncioimportaiojenkinsjenkins=aiojenkins.Jenkins('http://your_server/jenkins','user','password')asyncdefexample():awaitjenkins.builds.start('job_name',dict(parameter='test'))loop=asyncio.get_event_loop()try:loop.run_until_complete(example())finally:loop.run_until_complete(jenkins.close())loop.close()Please look at tests directory for more examples.DocumentationRead the DocsTestingCurrently tests aren’t using any mocking.
I am testing locally with dockerized LTS Jenkins ver. 2.222.3Prerequisites:docker, toxdocker run -d --name jenkins --restart always -p 8080:8080 jenkins/jenkins:lts
docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword
chromium http://localhost:8080  # create admin:admin
toxOr Jenkins 1.554docker run -d --name jenkins-1.554 --restart always -p 8081:8080 jenkins:1.554ContributingFeel free to PR
Package: aiojikan
AioJikanAn asynchronous api wrapper for theJikan API.FeaturesSimple and Easy to use100% API CoverageFully typehinted models (I tried my best at least)Usage of datetime objects where applicable for easy conversionsExamplesAll projects should create a single instance of AioJikan, provide it with an aiohttp.ClientSession if you want to, and you're good to go.importasyncioimportaiojikanasyncdefmain():client=aiojikan.AioJikan()love_is_war=awaitclient.get_anime(37999)print(f"Love is war has{love_is_war.favorites}favorites!")awaitclient.close()loop=asyncio.get_event_loop()loop.run_until_complete(main())LicenseThis library is licensed under the MIT license, please review ithere