Saravanan666/pypi-org huggingface dataset:
Package: aioworkers-aiohttp
The package to integration aioworkers with aiohttpFeaturesBuilding of the routing from config like swaggerStart aiohttp project with multiprocessing modeExamplehttp:port:8080access_log:format:%a %t "%r" %s %b "%{Referer}i" "%{User-Agent}i"app:routes:-mymodule.route_table-mymodule.routeresources:/html:static:static/html/css:static:path:static/cssapi:prefix:/apipets:/pet/{pet_id}:get:tags:[Pet]handler:mymodule.mycorodescription:Info about petparameters:-name:pet_idin:pathtype:integerminimum:0responses:200:description:OK400:description:Validation error404:description:Not foundDevelopmentCheck code:hatchrunlint:allFormat code:hatchrunlint:fmtRun tests:hatchrunpytestRun tests with coverage:hatchruncov
Package: aioworkers-boto
Aioworkers BotoTable of ContentsInstallationUseLicenseInstallationpip install aioworkers-botoUses3:cls:aioworkers_boto.storage.Storagebucket:mybucketpath:subdir/subsubdirconnection:endpoint_url:https://...aws_secret_access_key:'&124323453456789'aws_access_key_id:key-idregion_name:us-east-1format:jsonawaitcontext.s3.set(key,data)# save datad=awaitcontext.s3.get(key)# get dataawaitcontext.s3.set(key,None)# deleteLicenseaioworkers-botois distributed under the terms of theApache-2.0license.
Package: aioworkers-databases
aioworkers-databasesaioworkers plugin fordatabases.UsageAdd your database config to aioworkersconfig.yaml:db:cls:aioworkers_databases.database.Databasedsn:sqlite:///db.sqlitelogging:version:1disable_existing_loggers:falseroot:level:ERRORhandlers:[console]handlers:console:level:DEBUGclass:logging.StreamHandlerloggers:aioworkers_databases:level:ERRORhandlers:[console]propagate:trueRunaioworkers:aioworkers-cconfig.yaml-iCreateContextfor this config and use your db via context:awaitcontext.db.execute('CREATE TABLE some_table (id INT);')DevelopmentInstall requirements:poetryinstallRun tests:pytest
Package: aioworkers-mongo
aioworkers-mongoMongo plugin foraioworkers.UsageConnectionAdd this to aioworkers config.yaml:mongo:cls:aioworkers_mongo.base.Connectoruri:'mongodb://localhost:27017/'You can get access to mongo anywhere via context:docs=[docasyncfordocincontext.mongo.db.collection.find({})]Extended client configmongo:cls:aioworkers_mongo.base.Connectorclient:host:'localhost'port:27017DevelopmentRun Mongo DB:dockerrun--rm-p27017:27017--namemongo-dmongoInstall dev requirements:poetryinstallActivate env:..venv/bin/activateRun tests:pytest
Package: aioworkers-pg
aioworkers-pgAsyncpg plugin foraioworkers.UsageConnectionAdd this to aioworkers config.yaml:db:cls:aioworkers_pg.base.Connectordsn:postgresql:///testYou can get access to postgres anywhere via context:awaitcontext.db.execute('CREATE TABLE users(id serial PRIMARY KEY, name text)')awaitcontext.db.execute(users.insert().values(name='Bob'))Connection additionaldb:cls:aioworkers_pg.base.Connectordsn:postgresql:///testpool:min_size:1max_size:100Storagestorage:cls:aioworkers_pg.storage.RoStoragedsn:postgresql:///testtable:mytable# optional instead custom sqlkey:idget:SELECT * FROM mytable WHERE id = :id# optional custom sqlformat:dict# or rowDevelopmentInstall dev requirements:poetryinstallRun postgres:dockerrun--rm-p5432:5432--namepostgres-ePOSTGRES_PASSWORD=postgres-ePOSTGRES_DB=test-dpostgresRun tests:pytest
Package: aioworkers-prometheus
Usemetric:registry:aioworkersnamespace:aioworkers_test_metricmetrics:my_counter:type:countername:test_counterdocumentation:Counter for testsmy_histogram:type:histogramname:test_histogramdocumentation:Histogram for testsbuckets:[30,90,100,200,400,800]Use in codecontext.metric.my_counter.inc()context.metric.my_histogram.observe(542)withcontext.metric.my_histogram.time():awaitasyncio.sleep(1)Add global labels to default registry to expositionprometheus:registry:aioworkerslabels:env:prodServe port 8000 for prometheusprometheus:port:8000registry:aioworkersPush to graphite localhost:9090prometheus:registry:aioworkersgraphite:address:localhost:9090interval:1mprefix:aioworkers.testDevelopmentInstall dev requirements:pipenvinstall--dev--skip-lockRun tests:pipenvrunpytest
Package: aioworkers-redis
Redis plugin foraioworkers.FeaturesWorks onaioredisQueue based onRPUSH,BLPOP,LLEN,LRANGEZQueue based onZADD,ZRANGE,ZCARD,ZRANGE,ZREM,EVALTimestampZQueue based ZQueueStorage based onSET,GETHashStorage based onHSET,HGET,HDEL,HMSET,HMGET,HGETALLHyperLogLogStorage based onPFADD,PFMERGE,PFCOUNTUsageAdd this to aioworkers config.yaml:redis:cls:aioworkers_redis.base.Connectorprefix:appconnection:host:localhostport:6379maxsize:20queue:cls:aioworkers_redis.queue.Queueconnection:.redisformat:jsonkey:queueYou can work with redis queue like this:awaitcontext.queue.put({'a':1})d=awaitcontext.queue.get()
Package: aioworkers-sentry
aioworkers plugin to work with Sentry. Creates Sentry client and handler according configuration
and setup logging.UsageInstall plugin:pipinstallaioworkers-sentryAdd to your config:sentry:dsn:<your sentry dsn>release:1.0.0environment:DEVintegrations:-sentry_sdk.integrations.aiohttp.AioHttpIntegrationDevelopmentCheck code:hatchrunlint:allFormat code:hatchrunlint:fmtRun tests:hatchrunpytestRun tests with coverage:hatchruncov
Package: aioworkers-tg
Plugin to work withTelegraminaioworkers.Features:Telegram user.Telegram channels.Telegram groups.UsageInstall it with pip:pipinstallaioworkers-tgCreate entity of bot in aioworkers config:bot:cls:'aioworkers_tg.bot.TelegramBot'api_token:'1234567890'You can use it directly from context:awaitcontext.bot.channel('@yourchannel').send_text("Hello from channel!")Also it is possible to create chat instance and send messages directly:chat:cls:'aioworkers_tg.chat.TelegramChat'bot:'bot'# reference to created botgroup_id:'11111'awaitcontext.chat.send_text("Hello!")
Package: aiowowapi
aiowowapi docsAn asynchronous client library for interacting with the World of Warcraft API endpoints using theasync/awaitsyntax.Installing# Linux/OSXpython3-mpipinstall-Uaiowowapi# Windowspython-mpipinstall-UaiowowapiCurrent FeaturesRetail Game Data API SupportRetail Profile API SupportClassic Game Data API SupportRate limitingRequest retriesQoL WoW-Specific functions (Money -> Gold/Silver/Copper, Armoury link parser, etc)TODOAdd caching for certain requests (e.g. character profile)Greater test coverageRequirementsaiohttpPython 3.8+ExamplefromaiowowapiimportWowApiasyncdefmain():asyncwithWowApi('<ID>','<SECRET>','us',request_debugging=True)asClient:print(awaitClient.Retail.Profile.get_character_profile_status('illidan','adalyia'))Linksaiowowapi’s DocumentationBlizzard’s API DocumentationRegister a Blizzard API ClientBlizzard’s API ForumsIMPORTANTThis project is not affiliated with or endorsed byBlizzard Entertainment& all data is retrieved from official Blizzard / World of Warcraft APIs.Terms found here. Additionally this project was created primarily for use with Discord Bots & other async applications with inspiration fromthis projectbylockwooddev.
Package: aiowrap
Assume that you have some existing libraries with blocking methods:def foo_sync(x, a, b):
    """Some existing library methods. Sleeps for x seconds and returns a + b."""
    time.sleep(x)
    return a + bAnd you are writing a program in Python3’sasyncioframework. To use the
blocking library, one way is to use a thread pool. This library provides
another option:# Wraps foo_sync() into foo_async() to use in asyncio framework.
time.sleep = aiowrap.wrap_async(asyncio.sleep)
foo_async = aiowrap.wrap_sync(foo_sync)Now you have an asynchronous, non-blocking version of the method, you can call
it inside your favourite coroutine:async def main():
    print(await foo_async(1, 2, 3))The source code of this example can be found atexample/sleep.py.
Package: aiowwlln
⚡️ aiowwlln: A simple Python3 wrapper for WWLLNaiowwllnis a simple,asyncio-driven Python library for retrieving information on
lightning strikes fromthe World Wide Lightning Location Network (WWLLNN).NOTE:This library is built on an unofficial API; therefore, it may stop working at
any time.InstallationpipinstallaiowwllnPython Versionsaiowwllnis currently supported on:Python 3.6Python 3.7Python 3.8Usageaiowwllnstarts within anaiohttpClientSession:importasynciofromaiohttpimportClientSessionfromaiowwllnimportClientasyncdefmain()->None:"""Create the aiohttp session and run the example."""asyncwithClientSession()aswebsession:# YOUR CODE HEREasyncio.get_event_loop().run_until_complete(main())Create a client, initialize it, then get to it:importasynciofromdatetimeimportdatetimefromaiohttpimportClientSessionfromaiowwllnimportClientasyncdefmain()->None:"""Create the aiohttp session and run the example."""asyncwithClientSession()aswebsession:client=aiowwlln.Client(websession)# Create a client and get all strike data – by default, data is cached for# 60 seconds (be a responsible data citizen!):client=Client(websession)awaitclient.dump()# If you want to increase the cache to 24 hours, go for it:client=Client(websession,cache_seconds=60*60*24)awaitclient.dump()# Get strike data within a 50 km radius around a set of coordinates (note that# the cache still applies):awaitclient.within_radius(56.1621538,92.2333561,50,unit="metric")# Get strike data within a 10 mile radius around a set of coordinates (note that# the cache still applies):awaitclient.within_radius(56.1621538,92.2333561,10,unit="imperial")# Get strike data within a 50 km radius around a set of coordinates _and_# within the last 10 minutes:awaitclient.within_radius(56.1621538,92.2333561,50,unit="metric",window=timedelta(minutes=10))asyncio.get_event_loop().run_until_complete(main())ContributingCheck for open features/bugsorinitiate a discussion on one.Fork the repository.(optional, but highly recommended) Create a virtual environment:python3 -m venv .venv(optional, but highly recommended) Enter the virtual environment:source ./venv/bin/activateInstall the dev environment:script/setupCode your new feature or bug fix.Write tests that cover your new functionality.Run tests and ensure 100% code coverage:script/testUpdateREADME.mdwith any new documentation.Add yourself toAUTHORS.md.Submit a pull request!
Package: aio_wx_widgets
aio_wx_widgetsWx python app structure using MVC model. Work in progress, adding widgets when I need them.
See the demo folder for usage.Features:Add widgets using context managers.Two-way or one-way Property binding from controller properties to the view.Proper Margins and alignment of itemsThe example below is a bit outdated, but gives a rough idea. Please see the demo for more.```python
# Use a context manager for container types like a group or grid.
# A group is a container with a label and a sizer inside. Inside
# this sizer widgets, or other containers can be placed.
with self.add(Group("A labelled container.")) as group:
    group.add(Text(text="A horizontal grid."))

    with group.add(Grid()) as grd:
        # the binding binds to an attribute defined in the controller
        # the weight determines how much space a specific item should consume
        # with respect to the other members of the container.
        grd.add(IntEntry(binding=self.bind("value_1")), weight=6, margin=3)
        grd.add(IntEntry(binding=self.bind("value_1")), weight=4, margin=3)
        grd.add(IntEntry(binding=self.bind("value_1")), weight=4, margin=3)
```


```python
vert_grid.add(
    Text(text="Center aligned text with a large margin."),
    margin=(10, 10, 30, 5),  # (left,right,top,below)
    align_horizontal=AlignHorizontal.center,)
```InstallationCreate a virtual env, activate it andpip install aio_wx_widgetsRunning the demoInstall the libary as described above.clone the repo.from the activated virtualenv:python -m demo
Package: aio-xiq
Extreme Cloud IQ - Python3 AsyncIO ClientThis repository contains a Python3 asyncio based client library for interacting
with the Extreme Cloud IQ system (XIQ).Note that Extreme does provide their own Python SDK client, which can be found
in the reference section below.Installationpipinstallaio-xiqThis XIQ asyncio python client is a subclass from httpx.AsyncClient.QuickStartBefore using the API you must either have an existing token or login with your user-name + password
credentials.  You can either pass these values into the client constructor, or use these environment variables:XIQ_USER - the login user-nameXIQ_PASSWORD = the login password-- or --
* XIQ_TOKEN - an existing API tokenUsername + PasswordIf you are using your login credentials you must execute thelogin()method to obtain an access
token.fromaioxiqimportXiqClientasyncwithXiqClient(xiq_user='bob@corp.com',xiq_password='notarealpassword')asapi:awaitapi.login()devices=awaitapi.fetch_devices()API TokenYou can create an API token via the XIQ portal by nagivating to the Global
Settings page (found under your User profile near the top-right), and then
selecting the "API Token Management" option on the left sidebar.When using the API Token approach, you can use the client diretly without having
to perform the login function.fromaioxiqimportXiqClient# presume that XIQ_TOKEN environment variable is set with an existing token.# you can immediately use the API without login.asyncwithXiqClient()asapi:devices=api.fetch_devices()ReferencesExtreme Developer PortalExtreme XIQ API Online Docts, SwaggerExtreme XIQ APIs Github repoExtreme XIQ Python SDK Github repo
Package: aioxlsxstream
aioxlsxstreamGenerate the xlsx file on fly without storing entire file in memory.
Generated excel workbook contain only one sheet. All data writes as strings.Installationpip install aioxlsxstreamRequirementsPython 3.8+Simple exapmleimportaioxlsxstreamimportasyncioasyncdefmain():asyncdefrows_generaor():asyncdefrow_cells_generator(row):forcolinrange(5):yieldrow*5+colforrowinrange(10):yieldrow_cells_generator(row)xlsx_file=aioxlsxstream.XlsxFile()xlsx_file.write_sheet(rows_generaor())withopen("example.xlsx","wb")asf:asyncfordatainxlsx_file:f.write(data)asyncio.run(main())aiohttp Examplefromaiohttpimportweb,hdrsimportaioxlsxstreamasyncdefrows_generaor():asyncdefrow_cells_generator(row):forcolinrange(5):yieldrow*5+colforrowinrange(10):yieldrow_cells_generator(row)asyncdefhandle(request):filename="example.xlsx"response=web.StreamResponse(status=200,headers={hdrs.CONTENT_TYPE:"application/octet-stream",hdrs.CONTENT_DISPOSITION:(f"attachment; "f'filename="{filename}"; '),},)awaitresponse.prepare(request)xlsx_file=aioxlsxstream.XlsxFile()# or CsvFile("csv") or CsvFile("tsv")xlsx_file.write_sheet(rows_generaor())asyncfordatainxlsx_file:awaitresponse.write(data)returnresponseapp=web.Application()app.add_routes([web.get('/',handle)])if__name__=='__main__':web.run_app(app)
Package: aioxmlrpc
Asyncio version of the standard libxmlrpcCurrently onlyaioxmlrpc.client, which works likexmlrpc.clientbut
with coroutine is implemented.Fill free to fork me if you want to implement the server part.aioxmlrpcis based onhttpxfor the transport, and just patch
the necessary from the python standard library to get it working.Installationaioxmlrpc is available on PyPI, it can simply be installed with your favorite
tool, example with pip here.pip install aioxmlrpcGetting StartedThis example show how to print the current version of the Gandi XML-RPC api.import asyncio
from aioxmlrpc.client import ServerProxy


@asyncio.coroutine
def print_gandi_api_version():
    api = ServerProxy('https://rpc.gandi.net/xmlrpc/')
    result = yield from api.version.info()
    print(result)

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(print_gandi_api_version())
    loop.stop()Run the examplepoetry run examples/gandi_api_version.py
Package: aioxrpy
aioxrpyRipple blockchain library for Python.FeaturesAsync JSON-RPC client.Signing and verifying transactions using private and public keys.Support for signing transactions with multiple keys.Serializer and deserializer for Ripple objects.InstallationLibrary is available on PyPi, you can simply install it usingpip.$ pip install aioxrpyUsageKeysSigning and verifying transactions, as well as generating new accounts is done throughRippleKeyclass.from aioxrpy.keys import RippleKey

# New key
key = RippleKey()

# From public key
key = RippleKey(public_key=b'public key')

# From master seed
key = RippleKey(private_key='seed')

# From private key
key = RippleKey(private_key=b'private key')Such key can be converted to Account ID and public key.Submitting transactionsRPC client provides a helper which signs and submits transaction. As a first
argument it takes a transaction dict. The second one is aRippleKeyinstance
used for signing this transaction.from aioxrpy.rpc import RippleJsonRpc

rpc = RippleJsonRpc(url)
await rpc.sign_and_submit(
    {
        'Account': account,
        'TransactionType': RippleTransactionType.Payment,
        'Amount': decimals.xrp_to_drops(200),
        'Destination': destination,
        'Fee': 10
    },
    signer
)Multi-signed transactionsRPC client provides a helper which signs and submits transaction using multiple
keys. As a second argument, it expects a list ofRippleKeyinstances. Please
don't forget that each signer increases transaction fees.from aioxrpy.rpc import RippleJsonRpc

rpc = RippleJsonRpc(url)
await rpc.multisign_and_submit(
    {
        'Account': account,
        'TransactionType': RippleTransactionType.Payment,
        'Amount': decimals.xrp_to_drops(200),
        'Destination': destination,
        'Fee': 30
    },
    [signer_1, signer_2]
)DocumentationDocs and usage examples are availablehere.Unit testingTo run unit tests, you need to bootstrap a Rippled regtest node first. Use the provideddocker-compose.ymlfile.$ docker-compose up -d
Package: aioyagmail
aioyagmail -- Yet Another GMAIL/SMTP client, using AsyncIOThe goal here is to make it as simple and painless as possible to send emails using asyncio.In the end, your code will look something like this:importasynciofromaioyagmailimportAIOSMTPloop=asyncio.get_event_loop()asyncdefsend_single():# walks you through oauth2 process if no file at this locationasyncwithAIOSMTP(oauth2_file="~/oauth2_gmail.json")asyag:awaityag.send(to="someone@gmail.com",subject="hi")asyncdefsend_multi():asyncwithAIOSMTP(oauth2_file="~/oauth2_gmail.json")asyag:# Runs asynchronously!awaitasyncio.gather(yag.send(subject="1"),yag.send(subject="2"),yag.send(subject="3"))loop.run_until_complete(send_single())loop.run_until_complete(send_multi())Username and passwordIt is possible like inyagmailto use username and password, but this is not actively encouraged anymore.
Seehttps://github.com/kootenpv/yagmail#username-and-passwordhow to do it.For more informationHave a look atyagmail. Any issue NOT related to async should be posted there (or found out about).Word of cautionWatch out that gmail does not block you for spamming. Using async you could potentially be sending emails too rapidly.DonateIf you likeaioyagmail, feel free (no pun intended) to donate any amount you'd like :-)
Package: aio_yamlconfig
.. image:: https://img.shields.io/pypi/v/aio_yamlconfig.svg:target: https://pypi.org/project/aio_yamlconfig.. image:: https://img.shields.io/travis/rrader/aio_yamlconfig/master.svg:target: http://travis-ci.org/rrader/aio_yamlconfig.. image:: https://img.shields.io/pypi/pyversions/aio_yamlconfig.svg.. image:: https://img.shields.io/pypi/dm/aio_yamlconfig.svgaio_yamlconfig========Quick Start------------------Install from PYPI:.. code:: shellpip install aio_yamlconfigOR (less popular) via setup.py:.. code:: shellpython -m setup installYAML configuration parser with validation using `Trafaret <http://trafaret.readthedocs.org/en/latest/>`_.In the easiest setup without config validation, configure your ``aiohttp`` application with:.. code:: python:number-lines:CONFIG_FILE = os.path.join(os.path.dirname(__file__), "config.yaml")loop.run_until_complete(aio_yamlconfig.setup(app,config_files=[CONFIG_FILE],base_dir=os.path.dirname(__file__)))Assume you have ``config.yaml``:.. code:: yaml:number-lines:DEBUG: TrueTEMPLATES_DIR: !BaseDir path/to/templatesThen you can access your config as:.. code:: python:number-lines:if app.config['DEBUG']:print('some debug information')Notice the ``!BaseDir`` tag. ``aio_yamlconfig`` can do some config transformations for you, in this case it will prependthe base directory (passed as ``base_dir`` to ``setup()``) to your path. The variable ``app.config['TEMPLATES_DIR']`` will containthe full path to directory with your templates.Validation--------------------To validate your config we use the great library Trafaret. You can read more about it `in the docs <http://trafaret.readthedocs.org/en/latest/>`_.Here I'll give you a simple example of its usage.Let's write the validator for ``config.yaml`` above. We'd like to ensure that ``DEBUG`` value is boolean, and thatdirectory of the path ``TEMPLATES_DIR`` really exists:.. code:: python:number-lines:import trafaret as tfrom aio_yamlconfig.trafarets import ExistingDirectoryCONFIG_TRAFARET = t.Dict({t.Key('TEMPLATES_DIR'): ExistingDirectory,t.Key('DEBUG'): t.Bool})To enable such validation pass the ``trafaret_validator`` to ``setup()`` function:.. code:: python:number-lines:loop.run_until_complete(aio_yamlconfig.setup(app,config_files=[CONFIG_FILE],trafaret_validator=CONFIG_TRAFARET,base_dir=os.path.dirname(__file__)))
Package: aio-yandex-translate
aio_yandex_translateAsync yandex.translate api wrapper for pythonExample of usageimportasynciofromaio_yandex_translate.translatorimportTranslatorkey="TOKEN"asyncdefmain():text='Hello world'print(text)t=Translator(key)r=awaitt.translate(text,to_language='ru')print(r)loop=asyncio.get_event_loop()loop.run_until_complete(main())If you need to use proxiesimportasynciofromaio_yandex_translate.translatorimportTranslatorkey="TOKEN"asyncdefmain():text='Hello world't=Translator(key,proxy="http://user:password@127.0.0.1:1080")r=awaitt.translate(text,to_language='ru')print(r)loop=asyncio.get_event_loop()loop.run_until_complete(main())Seeaiohttp-proxy, it should also support socks proxiesChanging proxies on the goimportasynciofromaio_yandex_translate.translatorimportTranslatorkey="TOKEN"asyncdefmain():text='Hello world't=Translator(key,proxy="http://user:password@127.0.0.1:1080")r=awaitt.translate(text,to_language='ru')t.proxy="http://user:password@localhost:1080"r=awaitt.translate(text,to_language='ru')print(r)loop=asyncio.get_event_loop()loop.run_until_complete(main())Detecting languageasyncdefmain():text='Hello world't=Translator(key,proxy="http://user:password@127.0.0.1:1080")r=awaitt.detect_lang(text)print(r)loop=asyncio.get_event_loop()loop.run_until_complete(main())To add a new hint you should use the functionadd_hintwith passedlangparameter and in return you'll get bool value representing if it was addedTo remove lang from hints:fromaio_yandex_translate.translatorimportTranslatorkey="TOKEN"translator=Translator(key)translator.add_hint("en")translator.hints.remove("en")Explaining some detailsTo get to exceptions that module can throw you may go
to Translator.exc and see classes of exceptions (TranslatorError is base)The code is really short but i hope it will help you!
Package: aioymaps
aioymapsis an asynchronous library provides API to fetch json information
about transport stops from Yandex MapsRequirementsaioymapsrequires python 3.5 or higher due to async/await syntax and aiohttp
libraryInstallationUse pip to install the library:pip install aioymapsOr install manually.sudo python ./setup.py installUsagefrom aioymaps import YandexMapsRequester

requester = YandexMapsRequester()
data = await requester.get_stop_info('stop__10067199')
print(data)Or you can use it in your shell:python -m aioymaps -s group__219
Package: aioynab
YNABAPI client implemented using python 3 asyncio.Installaioynab can easily be installed using pip and python >= 3.5.3:$pipinstallaioynabQuick StartFirst create a personal access token in yourYNAB account.
Create a client with that value like the example below.importasynciofromaioynab.clientimportClientloop=asyncio.get_event_loop()client=Client('ynab-personal-access-token')budgets=loop.run_until_complete(client.budgets()))budget_id=budgets['budgets'][0]['budget_id']accounts=loop.run_until_complete(client.accounts(budget_id))account_id=accounts['accounts'][0]['account_id']transactions=loop.run_until_complete(client.account_transactions(budget_id,account_id))DocumentationConsult thedocsfor further information.