# packages

pkgId: bcee3399b339d0153369a9c338d091736d7a19b4635bf3c34425197bb2c9681b
name: python-aiocouch
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: 🛋 An asynchronous client library for CouchDB 2.x and 3.x
url: https://github.com/metricq/aiocouch
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiocouch-3.0.1-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
  [![PyPI version](https://badge.fury.io/py/aiocouch.svg)](https://badge.fury.io/py/aiocouch)
  ![Python package](https://github.com/metricq/aiocouch/workflows/Python%20package/badge.svg)
  [![codecov](https://codecov.io/gh/metricq/aiocouch/branch/master/graph/badge.svg)](https://codecov.io/gh/metricq/aiocouch)
  [![Documentation Status](https://readthedocs.org/projects/aiocouch/badge/?version=latest)](https://aiocouch.readthedocs.io/en/latest/?badge=latest)



  An asynchronous client library for CouchDB 2.0 based on asyncio using aiohttp



  - All requests are asynchronus using aiohttp
  - Supports CouchDB 2.x and 3.x
  - Support for modern Python ≥ 3.7




  ```
      pip install aiocouch
  ```



  The following code retrieves and prints the list of `incredients` of the *apple_pie* `recipe`.
  The `incredients` are stored as a list in the *apple_pie* `aiocouch.document.Document`,
  which is part of the `recipe` `aiocouch.database.Database`. We use the context manager
  `aiocouch.CouchDB` to create a new session.

  ```python

      from aiocouch import CouchDB

      async with CouchDB(
          "http://localhost:5984", user="admin", password="admin"
      ) as couchdb:
          db = await couchdb["recipes"]
          doc = await db["apple_pie"]
          print(doc["incredients"])
  ```

  We can also create new recipes, for instance for some delicious cookies.

  ```python

          new_doc = await db.create(
              "cookies", data={"title": "Granny's cookies", "rating": "★★★★★"}
          )
          await new_doc.save()
  ```

  For further details please refer to the documentation, which is available [here on readthedocs.org](https://aiocouch.readthedocs.io/).



  - Setup the CouchDB URL and credentials using the environment variables
  - Install dependencies using `pip install --editable '.[examples]'`
  - run for instance `python examples/getting_started.py`




  - Install dependencies using `pip install --editable '.[tests]'`
  - Setup the CouchDB URL and credentials using the environment variables (`COUCHDB_HOST`, `COUCHDB_USER`, `COUCHDB_PASS`)
  - run `pytest --cov=aiocouch`




  - Install dependencies using `pip install '.[docs]'`
  - switch to the `docs` directory: `cd docs`
  - run `make html`


pkgId: e91c40e2115aa5a00cb0d9ef1437c608ab3a7e83dc8f9bfb19264fe5017caac2
name: python-aiocpa
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: sync & async Crypto Pay API client.
url: https://github.com/vovchic17/aiocpa
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiocpa-0.1.11-1.src.rpm
checksum_type: sha256
description:
  [![Python](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/vovchic17/static/main/src/badges/python310_313.json)](https://www.python.org/)
  [![Crypto Pay API](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/vovchic17/static/refs/heads/main/src/badges/cryptopayapi.json)](https://help.crypt.bot/crypto-pay-api)
  [![Pydantic v2](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/pydantic/pydantic/main/docs/badge/v2.json)](https://pydantic.dev)
  [![Aiohttp](https://img.shields.io/badge/aiohttp-v3-2c5bb4?logo=aiohttp)](https://docs.aiohttp.org/en/stable/)
  [![Code linter: ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/charliermarsh/ruff)
  [![Checked with mypy](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/vovchic17/static/main/src/badges/mypy.json)](https://mypy-lang.org/)

  **aiocpa** is a syncronous & asynchronous [Crypto Pay API](https://help.crypt.bot/crypto-pay-api) client.

  > ## [Official documentation](https://aiocpa.readthedocs.io/en/latest/)


  ```python
  import asyncio
  from cryptopay import CryptoPay


  async def main():
      cp = CryptoPay(token="TOKEN")
      app = await cp.get_me()
      print(app.name)  # Your App Name


  if __name__ == "__main__":
      asyncio.run(main())
  ```



  ```python
  import asyncio
  from aiogram import Bot, Dispatcher
  from cryptopay import CryptoPay

  cp = CryptoPay("TOKEN")
  bot = Bot("TOKEN")
  dp = Dispatcher()


  @dp.message()
  async def get_invoice(message):
      invoice = await cp.create_invoice(1, "USDT")
      await message.answer(f"pay: {invoice.bot_invoice_url}")
      invoice.await_payment(message=message)


  @cp.polling_handler()
  async def handle_payment(invoice, message):
      await message.answer(f"invoice #{invoice.invoice_id} has been paid")


  async def main():
      await asyncio.gather(
          dp.start_polling(bot),
          cp.run_polling(),
      )


  if __name__ == "__main__":
      asyncio.run(main())
  ```


pkgId: fa512c0cea76ba5b9ecfa911e8b7b56ff8d7b80429ed5b50d7691b3c09681912
name: python-aiocpa
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: sync & async Crypto Pay API client.
url: https://github.com/vovchic17/aiocpa
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiocpa-0.1.12-1.src.rpm
checksum_type: sha256
description:
  [![Python](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/vovchic17/static/main/src/badges/python310_313.json)](https://www.python.org/)
  [![Crypto Pay API](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/vovchic17/static/refs/heads/main/src/badges/cryptopayapi.json)](https://help.crypt.bot/crypto-pay-api)
  [![Documentation Status](https://readthedocs.org/projects/aiocpa/badge/?version=latest)](https://aiocpa.readthedocs.io/en/latest/?badge=latest)
  [![Pydantic v2](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/pydantic/pydantic/main/docs/badge/v2.json)](https://pydantic.dev)
  [![Aiohttp](https://img.shields.io/badge/aiohttp-v3-2c5bb4?logo=aiohttp)](https://docs.aiohttp.org/en/stable/)
  [![Code linter: ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/charliermarsh/ruff)
  [![Checked with mypy](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/vovchic17/static/main/src/badges/mypy.json)](https://mypy-lang.org/)

  **aiocpa** is a syncronous & asynchronous [Crypto Pay API](https://help.crypt.bot/crypto-pay-api) client.

  > ## [Official documentation](https://aiocpa.readthedocs.io/en/latest/)


  ```python
  import asyncio
  from cryptopay import CryptoPay


  async def main():
      cp = CryptoPay(token="TOKEN")
      app = await cp.get_me()
      print(app.name)  # Your App Name


  if __name__ == "__main__":
      asyncio.run(main())
  ```



  ```python
  import asyncio
  from aiogram import Bot, Dispatcher
  from cryptopay import CryptoPay

  cp = CryptoPay("TOKEN")
  bot = Bot("TOKEN")
  dp = Dispatcher()


  @dp.message()
  async def get_invoice(message):
      invoice = await cp.create_invoice(1, "USDT")
      await message.answer(f"pay: {invoice.bot_invoice_url}")
      invoice.await_payment(message=message)


  @cp.polling_handler()
  async def handle_payment(invoice, message):
      await message.answer(f"invoice #{invoice.invoice_id} has been paid")


  async def main():
      await asyncio.gather(
          dp.start_polling(bot),
          cp.run_polling(),
      )


  if __name__ == "__main__":
      asyncio.run(main())
  ```


pkgId: 4366cfd6b4d2c83cdafa7f4b671389c039a7d0e97ca180a33a68d2f924483377
name: python-aiocqhttp
arch: src
version: 1.4.4
epoch: 0
release: 1
summary: A Python SDK with async I/O for OneBot (CQHTTP).
url: https://github.com/nonebot/aiocqhttp
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiocqhttp-1.4.4-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/nonebot/aiocqhttp.svg)](LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/aiocqhttp.svg)](https://pypi.python.org/pypi/aiocqhttp)
  ![Python Version](https://img.shields.io/badge/python-3.7+-blue.svg)
  ![OneBot Version](https://img.shields.io/badge/OneBot-v10,v11-black.svg)

  **aiocqhttp** 是 [OneBot](https://github.com/howmanybots/onebot) (原 [酷Q](https://cqp.cc) 的 [CQHTTP 插件](https://cqhttp.cc)) 的 Python SDK，采用异步 I/O，封装了 web 服务器相关的代码，支持 OneBot 的 HTTP 和反向 WebSocket 两种通信方式，让使用 Python 的开发者能方便地开发插件。

  本 SDK 要求使用 Python 3.7 或更高版本，以及建议搭配支持 OneBot v11 的 OneBot 实现。



  使用方法见 [文档](https://aiocqhttp.nonebot.dev/)。



  如果在使用本 SDK 时遇到任何问题，请 [提交 issue](https://github.com/nonebot/aiocqhttp/issues/new)，也欢迎参与项目开发，具体流程请参考 [贡献指南](CONTRIBUTING.md)。


pkgId: de2aad9d0a44329e14e8cc65f3fa1e7d8f2cc1056aaf516459b59b4714c1925e
name: python-aiocryptopay
arch: src
version: 0.4.6
epoch: 0
release: 1
summary: @cryptobot api asynchronous python wrapper
url: https://github.com/layerqa/aiocryptopay
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiocryptopay-0.4.6-1.src.rpm
checksum_type: sha256
description:
  **Docs:** https://help.crypt.bot/crypto-pay-api

   - MainNet - [@CryptoBot](http://t.me/CryptoBot)
   - TestNet - [@CryptoTestnetBot](http://t.me/CryptoTestnetBot)


  **Install**
  ``` bash
  pip install aiocryptopay
  poetry add aiocryptopay
  ```

  **Basic methods**
  ``` python
  from aiocryptopay import AioCryptoPay, Networks

  crypto = AioCryptoPay(token='1337:JHigdsaASq', network=Networks.MAIN_NET)

  profile = await crypto.get_me()
  currencies = await crypto.get_currencies()
  balance = await crypto.get_balance()
  rates = await crypto.get_exchange_rates()
  stats = await crypto.get_stats()

  print(profile, currencies, balance, rates, stats, sep='\n')
  ```

  **Create, get and delete invoice methods**
  ``` python
  from aiocryptopay import AioCryptoPay, Networks

  crypto = AioCryptoPay(token='1337:JHigdsaASq', network=Networks.MAIN_NET)

  invoice = await crypto.create_invoice(asset='TON', amount=1.5)
  print(invoice.bot_invoice_url)


  fiat_invoice = await crypto.create_invoice(amount=5, fiat='USD', currency_type='fiat')
  print(fiat_invoice)

  old_invoice = await crypto.get_invoices(invoice_ids=invoice.invoice_id)
  print(old_invoice.status)

  deleted_invoice = await crypto.delete_invoice(invoice_id=invoice.invoice_id)
  print(deleted_invoice)
  ```

  **Create, get and delete check methods**
  ``` python


  from aiocryptopay import AioCryptoPay, Networks

  crypto = AioCryptoPay(token='1337:JHigdsaASq', network=Networks.MAIN_NET)

  check = await crypto.create_check(asset='USDT', amount=1)
  print(check)

  old_check = await crypto.get_checks(check_ids=check.check_id)
  print(old_check)

  deleted_check = await crypto.delete_check(check_id=check.check_id)
  print(deleted_check)
  ```


  **WebHook usage**
  ``` python
  from aiohttp import web

  from aiocryptopay import AioCryptoPay, Networks
  from aiocryptopay.models.update import Update


  web_app = web.Application()
  crypto = AioCryptoPay(token='1337:JHigdsaASq', network=Networks.MAIN_NET)


  @crypto.pay_handler()
  async def invoice_paid(update: Update, app) -> None:
      print(update)

  async def create_invoice(app) -> None:
      invoice = await crypto.create_invoice(asset='TON', amount=1.5)
      print(invoice.bot_invoice_url)

  async def close_session(app) -> None:
      await crypto.close()


  web_app.add_routes([web.post('/crypto-secret-path', crypto.get_updates)])
  web_app.on_startup.append(create_invoice)
  web_app.on_shutdown.append(close_session)
  web.run_app(app=web_app, host='localhost', port=3001)
  ```


pkgId: a7f6f3e6922da3aa7980a0d4d0fc4491a08874514fe6f64721f657d543a16a9c
name: python-aiocsv
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/MKuranowski/aiocsv
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiocsv-1.3.2-1.src.rpm
checksum_type: sha256
description:
  Asynchronous CSV reading and writing.




  `pip install aiocsv`. Python 3.8+ is required.

  This module contains an extension written in C. Pre-build binaries
  may not be available for your configuration. You might need a C compiler
  and Python headers to install aiocsv.




  AsyncReader & AsyncDictReader accept any object that has a `read(size: int)` coroutine,
  which should return a string.

  AsyncWriter & AsyncDictWriter accept any object that has a `write(b: str)` coroutine.

  Reading is implemented using a custom CSV parser, which should behave exactly like the CPython parser.

  Writing is implemented using the synchronous csv.writer and csv.DictWriter objects -
  the serializers write data to a StringIO, and that buffer is then rewritten to the underlying
  asynchronous file.




  Example usage with [aiofiles](https://pypi.org/project/aiofiles/).

  ```python
  import asyncio
  import csv

  import aiofiles
  from aiocsv import AsyncReader, AsyncDictReader, AsyncWriter, AsyncDictWriter

  async def main():
      
      async with aiofiles.open("some_file.csv", mode="r", encoding="utf-8", newline="") as afp:
          async for row in AsyncReader(afp):
              print(row)  # row is a list

      
      async with aiofiles.open("some_other_file.tsv", mode="r", encoding="utf-8", newline="") as afp:
          async for row in AsyncDictReader(afp, delimiter="\t"):
              print(row)  # row is a dict

      
      async with aiofiles.open("new_file.csv", mode="w", encoding="utf-8", newline="") as afp:
          writer = AsyncWriter(afp, dialect="unix")
          await writer.writerow(["name", "age"])
          await writer.writerows([
              ["John", 26], ["Sasha", 42], ["Hana", 37]
          ])

      
      async with aiofiles.open("new_file2.csv", mode="w", encoding="utf-8", newline="") as afp:
          writer = AsyncDictWriter(afp, ["name", "age"], restval="NULL", quoting=csv.QUOTE_ALL)
          await writer.writeheader()
          await writer.writerow({"name": "John", "age": 26})
          await writer.writerows([
              {"name": "Sasha", "age": 42},
              {"name": "Hana"}
          ])

  asyncio.run(main())
  ```



  `aiocsv` strives to be a drop-in replacement for Python's builtin
  [csv module](https://docs.python.org/3/library/csv.html). However, there are 3 notable differences:

  - Readers accept objects with async `read` methods, instead of an AsyncIterable over lines
      from a file.
  - `AsyncDictReader.fieldnames` can be `None` - use `await AsyncDictReader.get_fieldnames()` instead.
  - Changes to `csv.field_size_limit` are not picked up by existing Reader instances.
      The field size limit is cached on Reader instantiation to avoid expensive function calls
      on each character of the input.

  Other, minor, differences include:
  - `AsyncReader.line_num`, `AsyncDictReader.line_num` and `AsyncDictReader.dialect` are not settable,
  - `AsyncDictReader.reader` is of `AsyncReader` type,
  - `AsyncDictWriter.writer` is of `AsyncWriter` type,
  - `AsyncDictWriter` provides an extra, read-only `dialect` property.







  ```
  AsyncReader(
      asyncfile: aiocsv.protocols.WithAsyncRead,
      dialect: str | csv.Dialect | Type[csv.Dialect] = "excel",
      **csv_dialect_kwargs: Unpack[aiocsv.protocols.CsvDialectKwargs],
  )
  ```

  An object that iterates over records in the given asynchronous CSV file.
  Additional keyword arguments are understood as dialect parameters.

  Iterating over this object returns parsed CSV rows (`List[str]`).

  *Methods*:
  - `__aiter__(self) -> self`
  - `async __anext__(self) -> List[str]`

  *Read-only properties*:
  - `dialect`: The csv.Dialect used when parsing
  - `line_num`: The number of lines read from the source file. This coincides with a 1-based index
      of the line number of the last line of the recently parsed record.




  ```
  AsyncDictReader(
      asyncfile: aiocsv.protocols.WithAsyncRead,
      fieldnames: Optional[Sequence[str]] = None,
      restkey: Optional[str] = None,
      restval: Optional[str] = None,
      dialect: str | csv.Dialect | Type[csv.Dialect] = "excel",
      **csv_dialect_kwargs: Unpack[aiocsv.protocols.CsvDialectKwargs],
  )
  ```

  An object that iterates over records in the given asynchronous CSV file.
  All arguments work exactly the same was as in csv.DictReader.

  Iterating over this object returns parsed CSV rows (`Dict[str, str]`).

  *Methods*:
  - `__aiter__(self) -> self`
  - `async __anext__(self) -> Dict[str, str]`
  - `async get_fieldnames(self) -> List[str]`


  *Properties*:
  - `fieldnames`: field names used when converting rows to dictionaries
      **⚠️** Unlike csv.DictReader, this property can't read the fieldnames if they are missing -
      it's not possible to `await` on the header row in a property getter.
      **Use `await reader.get_fieldnames()`**.
      ```py
      reader = csv.DictReader(some_file)
      reader.fieldnames  # ["cells", "from", "the", "header"]

      areader = aiofiles.AsyncDictReader(same_file_but_async)
      areader.fieldnames   # ⚠️ None
      await areader.get_fieldnames()  # ["cells", "from", "the", "header"]
      ```
  - `restkey`: If a row has more cells then the header, all remaining cells are stored under
      this key in the returned dictionary. Defaults to `None`.
  - `restval`: If a row has less cells then the header, then missing keys will use this
      value. Defaults to `None`.
  - `reader`: Underlying `aiofiles.AsyncReader` instance

  *Read-only properties*:
  - `dialect`: Link to `self.reader.dialect` - the current csv.Dialect
  - `line_num`: The number of lines read from the source file. This coincides with a 1-based index
      of the line number of the last line of the recently parsed record.




  ```
  AsyncWriter(
      asyncfile: aiocsv.protocols.WithAsyncWrite,
      dialect: str | csv.Dialect | Type[csv.Dialect] = "excel",
      **csv_dialect_kwargs: Unpack[aiocsv.protocols.CsvDialectKwargs],
  )
  ```

  An object that writes csv rows to the given asynchronous file.
  In this object "row" is a sequence of values.

  Additional keyword arguments are passed to the underlying csv.writer instance.

  *Methods*:
  - `async writerow(self, row: Iterable[Any]) -> None`:
      Writes one row to the specified file.
  - `async writerows(self, rows: Iterable[Iterable[Any]]) -> None`:
      Writes multiple rows to the specified file.

  *Readonly properties*:
  - `dialect`: Link to underlying's csv.writer's `dialect` attribute




  ```
  AsyncDictWriter(
      asyncfile: aiocsv.protocols.WithAsyncWrite,
      fieldnames: Sequence[str],
      restval: Any = "",
      extrasaction: Literal["raise", "ignore"] = "raise",
      dialect: str | csv.Dialect | Type[csv.Dialect] = "excel",
      **csv_dialect_kwargs: Unpack[aiocsv.protocols.CsvDialectKwargs],
  )
  ```

  An object that writes csv rows to the given asynchronous file.
  In this object "row" is a mapping from fieldnames to values.

  Additional keyword arguments are passed to the underlying csv.DictWriter instance.

  *Methods*:
  - `async writeheader(self) -> None`: Writes header row to the specified file.
  - `async writerow(self, row: Mapping[str, Any]) -> None`:
      Writes one row to the specified file.
  - `async writerows(self, rows: Iterable[Mapping[str, Any]]) -> None`:
      Writes multiple rows to the specified file.

  *Properties*:
  - `fieldnames`: Sequence of keys to identify the order of values when writing rows
      to the underlying file
  - `restval`: Placeholder value used when a key from fieldnames is missing in a row,
      defaults to `""`
  - `extrasaction`: Action to take when there are keys in a row, which are not present in
      fieldnames, defaults to `"raise"` which causes ValueError to be raised on extra keys,
      may be also set to `"ignore"` to ignore any extra keys
  - `writer`: Link to the underlying `AsyncWriter`

  *Readonly properties*:
  - `dialect`: Link to underlying's csv.reader's `dialect` attribute



  A `typing.Protocol` describing an asynchronous file, which can be read.



  A `typing.Protocol` describing an asynchronous file, which can be written to.



  Type of the `dialect` argument, as used in the `csv` module.



  Keyword arguments used by `csv` module to override the dialect settings during reader/writer
  instantiation.



  Contributions are welcome, however please open an issue beforehand. `aiocsv` is meant as
  a replacement for the built-in `csv`, any features not present in the latter will be rejected.



  To create a wheel (and a source tarball), run `python -m build`.

  For local development, use a [virtual environment](https://docs.python.org/3/library/venv.html).
  `pip install --editable .` will build the C extension and make it available for the current
  venv. This is required for running the tests. However, [due to the mess of Python packaging](https://docs.python.org/3/library/venv.html)
  this will force an optimized build without debugging symbols. If you need to debug the C part
  of aiocsv and build the library with e.g. debugging symbols, the only sane way is to
  run `python setup.py build --debug` and manually copy the shared object/DLL from `build/lib*/aiocsv`
  to `aiocsv`.



  This project uses [pytest](https://docs.pytest.org/en/latest/contents.html) with
  [pytest-asyncio](https://pypi.org/project/pytest-asyncio/) for testing. Run `pytest`
  after installing the library in the manner explained above.



  This library uses [black](https://pypi.org/project/black/) and [isort](https://pypi.org/project/isort/)
  for formatting and [pyright](https://github.com/microsoft/pyright) in strict mode for type checking.

  For the C part of library, please use [clang-format](https://clang.llvm.org/docs/ClangFormat.html)
  for formatting and [clang-tidy](https://clang.llvm.org/extra/clang-tidy/) linting,
  however this are not yet integrated in the CI.



  `pip install -r requirements.dev.txt` will pull all of the development tools mentioned above,
  however this might not be necessary depending on your setup. For example, if you use VS Code
  with the Python extension, pyright is already bundled and doesn't need to be installed again.



  Use [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python),
  [Pylance](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  (should be installed automatically alongside Python extension),
  [black](https://marketplace.visualstudio.com/items?itemName=ms-python.black-formatter) and
  [isort](https://marketplace.visualstudio.com/items?itemName=ms-python.isort) Python extensions.

  You will need to install all dev dependencies from `requirements.dev.txt`, except for `pyright`.
  Recommended `.vscode/settings.json`:

  ```json
  {
      "C_Cpp.codeAnalysis.clangTidy.enabled": true,
      "python.testing.pytestArgs": [
          "."
      ],
      "python.testing.unittestEnabled": false,
      "python.testing.pytestEnabled": true,
      "[python]": {
          "editor.formatOnSave": true,
          "editor.codeActionsOnSave": {
              "source.organizeImports": "always"
          }
      },
      "[c]": {
          "editor.formatOnSave": true
      }
  }
  ```

  For the C part of the library, [C/C++ extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools) is sufficient.
  Ensure that your system has Python headers installed. Usually a separate package like python3-dev
  needs to be installed, consult with your system repositories on that. `.vscode/c_cpp_properties.json`
  needs to manually include Python headers under `includePath`. On my particular system this
  config file looks like this:

  ```json
  {
      "configurations": [
          {
              "name": "Linux",
              "includePath": [
                  "${workspaceFolder}/**",
                  "/usr/include/python3.11"
              ],
              "defines": [],
              "compilerPath": "/usr/bin/clang",
              "cStandard": "c17",
              "cppStandard": "c++17",
              "intelliSenseMode": "linux-clang-x64"
          }
      ],
      "version": 4
  }
  ```


pkgId: 0d3c97b037d29e4e2fe8eb35fcfe484140978689e2ae186c74cb23c778e404fd
name: python-aiodataloader
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Asyncio DataLoader implementation for Python
url: https://github.com/syrusakbary/aiodataloader
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiodataloader-0.4.0-1.src.rpm
checksum_type: sha256
description:
  DataLoader is a generic utility to be used as part of your application's data
  fetching layer to provide a simplified and consistent API over various remote
  data sources such as databases or web services via batching and caching.

  [![PyPI version](https://badge.fury.io/py/aiodataloader.svg)](https://badge.fury.io/py/aiodataloader)
  ![Test Status](https://github.com/syrusakbary/aiodataloader/actions/workflows/test.yml/badge.svg)
  ![Lint Status](https://github.com/syrusakbary/aiodataloader/actions/workflows/lint.yml/badge.svg)
  [![Coverage Status](https://coveralls.io/repos/syrusakbary/aiodataloader/badge.svg?branch=master&service=github)](https://coveralls.io/github/syrusakbary/aiodataloader?branch=master)

  A port of the "Loader" API originally developed by [@schrockn][] at Facebook in
  2010 as a simplifying force to coalesce the sundry key-value store back-end
  APIs which existed at the time. At Facebook, "Loader" became one of the
  implementation details of the "Ent" framework, a privacy-aware data entity
  loading and caching layer within web server product code. This ultimately became
  the underpinning for Facebook's GraphQL server implementation and type
  definitions.

  Asyncio DataLoader is a Python port of the original JavaScript [DataLoader][]
  implementation. DataLoader is often used when implementing a [GraphQL][] service,
  though it is also broadly useful in other situations.




  First, install DataLoader using pip.

  ```sh
  pip install aiodataloader
  ```

  To get started, create a `DataLoader`. Each `DataLoader` instance represents a
  unique cache. Typically instances are created per request when used within a
  web-server like [Sanic][] if different users can see different things.

  > Note: DataLoader assumes a AsyncIO environment with `async/await`
    available only in Python 3.5+.




  Batching is not an advanced feature, it's DataLoader's primary feature.
  Create loaders by providing a batch loading function.

  ```python
  from aiodataloader import DataLoader

  class UserLoader(DataLoader):
      async def batch_load_fn(self, keys):
          return await my_batch_get_users(keys)

  user_loader = UserLoader()
  ```

  A batch loading function accepts an Iterable of keys, and returns a Promise which
  resolves to a List of values[<sup>*</sup>](#batch-function).

  Then load individual values from the loader. DataLoader will coalesce all
  individual loads which occur within a single frame of execution (a single tick
  of the event loop) and then call your batch function with all requested keys.

  ```python
  user1_future = user_loader.load(1)
  user2_future = user_loader.load(2)

  user1 = await user1_future
  user2 = await user2_future

  user1_invitedby = user_loader.load(user1.invited_by_id)
  user2_invitedby = user_loader.load(user2.invited_by_id)

  print("User 1 was invited by", await user1_invitedby)
  print("User 2 was invited by", await user2_invitedby)
  ```

  A naive application may have issued four round-trips to a backend for the
  required information, but with DataLoader this application will make at most
  two.

  DataLoader allows you to decouple unrelated parts of your application without
  sacrificing the performance of batch data-loading. While the loader presents an
  API that loads individual values, all concurrent requests will be coalesced and
  presented to your batch loading function. This allows your application to safely
  distribute data fetching requirements throughout your application and maintain
  minimal outgoing data requests.



  A batch loading function accepts an List of keys, and returns a Future which
  resolves to a List of values. There are a few constraints that must be upheld:

   * The List of values must be the same length as the List of keys.
   * Each index in the List of values must correspond to the same index in the List of keys.

  For example, if your batch function was provided the List of keys: `[ 2, 9, 6, 1 ]`,
  and loading from a back-end service returned the values:

  ```python
  { 'id': 9, 'name': 'Chicago' }
  { 'id': 1, 'name': 'New York' }
  { 'id': 2, 'name': 'San Francisco' }
  ```

  Our back-end service returned results in a different order than we requested, likely
  because it was more efficient for it to do so. Also, it omitted a result for key `6`,
  which we can interpret as no value existing for that key.

  To uphold the constraints of the batch function, it must return an List of values
  the same length as the List of keys, and re-order them to ensure each index aligns
  with the original keys `[ 2, 9, 6, 1 ]`:

  ```python
  [
    { 'id': 2, 'name': 'San Francisco' },
    { 'id': 9, 'name': 'Chicago' },
    None,
    { 'id': 1, 'name': 'New York' }
  ]
  ```




  DataLoader provides a memoization cache for all loads which occur in a single
  request to your application. After `.load()` is called once with a given key,
  the resulting value is cached to eliminate redundant loads.

  In addition to relieving pressure on your data storage, caching results per-request
  also creates fewer objects which may relieve memory pressure on your application:

  ```python
  user_future1 = user_loader.load(1)
  user_future2 = user_loader.load(1)

  assert user_future1 == user_future2
  ```



  DataLoader caching *does not* replace Redis, Memcache, or any other shared
  application-level cache. DataLoader is first and foremost a data loading mechanism,
  and its cache only serves the purpose of not repeatedly loading the same data in
  the context of a single request to your Application. To do this, it maintains a
  simple in-memory memoization cache (more accurately: `.load()` is a memoized function).

  Avoid multiple requests from different users using the DataLoader instance, which
  could result in cached data incorrectly appearing in each request. Typically,
  DataLoader instances are created when a Request begins, and are not used once the
  Request ends.

  For example, when using with [Sanic][]:

  ```python
  def create_loaders(auth_token) {
      return {
        'users': user_loader,
      }
  }


  app = Sanic(__name__)

  @app.route("/")
  async def test(request):
      auth_token = authenticate_user(request)
      loaders = create_loaders(auth_token)
      return render_page(request, loaders)
  ```



  In certain uncommon cases, clearing the request cache may be necessary.

  The most common example when clearing the loader's cache is necessary is after
  a mutation or update within the same request, when a cached value could be out of
  date and future loads should not use any possibly cached value.

  Here's a simple example using SQL UPDATE to illustrate.

  ```python

  user_loader = ...


  user4 = await user_loader.load(4)


  await sql_run('UPDATE users WHERE id=4 SET username="zuck"')
  user_loader.clear(4)


  user4 = await user_loader.load(4)


  ```



  If a batch load fails (that is, a batch function throws or returns a rejected
  Promise), then the requested values will not be cached. However if a batch
  function returns an `Exception` instance for an individual value, that `Exception` will
  be cached to avoid frequently loading the same `Exception`.

  In some circumstances you may wish to clear the cache for these individual Errors:

  ```python
  try:
      user_loader.load(1)
  except Exception as e:
      user_loader.clear(1)
      raise
  ```



  In certain uncommon cases, a DataLoader which *does not* cache may be desirable.
  Calling `DataLoader(batch_fn, cache=false)` will ensure that every
  call to `.load()` will produce a *new* Future, and requested keys will not be
  saved in memory.

  However, when the memoization cache is disabled, your batch function will
  receive an array of keys which may contain duplicates! Each key will be
  associated with each call to `.load()`. Your batch loader should provide a value
  for each instance of the requested key.

  For example:

  ```python
  class MyLoader(DataLoader):
      cache = False
      async def batch_load_fn(self, keys):
          print(keys)
          return keys

  my_loader = MyLoader()

  my_loader.load('A')
  my_loader.load('B')
  my_loader.load('A')


  ```

  More complex cache behavior can be achieved by calling `.clear()` or `.clear_all()`
  rather than disabling the cache completely. For example, this DataLoader will
  provide unique keys to a batch function due to the memoization cache being
  enabled, but will immediately clear its cache when the batch function is called
  so later requests will load new values.

  ```python
  class MyLoader(DataLoader):
      cache = False
      async def batch_load_fn(self, keys):
          self.clear_all()
          return keys
  ```






  DataLoader creates a public API for loading data from a particular
  data back-end with unique keys such as the `id` column of a SQL table or
  document name in a MongoDB database, given a batch loading function.

  Each `DataLoader` instance contains a unique memoized cache. Use caution when
  used in long-lived applications or those which serve many users with different
  access permissions and consider creating a new instance per web request.



  Create a new `DataLoader` given a batch loading function and options.

  - *batch_load_fn*: An async function (coroutine) which accepts an List of keys
    and returns a Future which resolves to an List of values.

  - *options*:

    - *batch*: Default `True`. Set to `False` to disable batching, instead
      immediately invoking `batch_load_fn` with a single load key.

    - *max_batch_size*: Default `Infinity`. Limits the number of items that get
      passed in to the `batch_load_fn`.

    - *cache*: Default `True`. Set to `False` to disable memoization caching,
      instead creating a new Promise and new key in the `batch_load_fn` for every
      load of the same key.

    - *cache_key_fn*: A function to produce a cache key for a given load key.
      Defaults to `key => key`. Useful to provide when Python objects are keys
      and two similarly shaped objects should be considered equivalent.

    - *cache_map*: An instance of [dict][] (or an object with a similar API) to be
      used as the underlying cache for this loader. Default `{}`.



  Loads a key, returning a `Future` for the value represented by that key.

  - *key*: An key value to load.



  Loads multiple keys, promising an array of values:

  ```python
  a, b = await my_loader.load_many([ 'a', 'b' ]);
  ```

  This is equivalent to the more verbose:

  ```python
  from asyncio import gather
  a, b = await gather(
      my_loader.load('a'),
      my_loader.load('b')
  )
  ```

  - *keys*: A list of key values to load.



  Clears the value at `key` from the cache, if it exists. Returns itself for
  method chaining.

  - *key*: An key value to clear.



  Clears the entire cache. To be used when some event results in unknown
  invalidations across this particular `DataLoader`. Returns itself for
  method chaining.



  Primes the cache with the provided key and value. If the key already exists, no
  change is made. (To forcefully prime the cache, clear the key first with
  `loader.clear(key).prime(key, value)`.) Returns itself for method chaining.




  DataLoader pairs nicely well with [GraphQL][]. GraphQL fields are
  designed to be stand-alone functions. Without a caching or batching mechanism,
  it's easy for a naive GraphQL server to issue new database requests each time a
  field is resolved.

  Consider the following GraphQL request:

  ```
  {
    me {
      name
      bestFriend {
        name
      }
      friends(first: 5) {
        name
        bestFriend {
          name
        }
      }
    }
  }
  ```

  Naively, if `me`, `bestFriend` and `friends` each need to request the backend,
  there could be at most 13 database requests!

  When using DataLoader with [graphene][], we could define the `User` type with clearer code and
  at most 4 database requests, and possibly fewer if there are cache hits.

  ```python
  class User(graphene.ObjectType):
      name = graphene.String()
      best_friend = graphene.Field(lambda: User)
      friends = graphene.List(lambda: User)

      def resolve_best_friend(self, args, context, info):
          return user_loader.load(self.best_friend_id)

      def resolve_friends(self, args, context, info):
          return user_loader.load_many(self.friend_ids)
  ```






  In many applications, a web server using DataLoader serves requests to many
  different users with different access permissions. It may be dangerous to use
  one cache across many users, and is encouraged to create a new DataLoader
  per request:

  ```python
  def create_loaders(auth_token):
    return {
      'users': DataLoader(lambda ids: gen_users(auth_token, ids)),
      'cdn_urls': DataLoader(lambda raw_urls: gen_cdn_urls(auth_token, raw_urls)),
      'stories': DataLoader(lambda keys: gen_stories(auth_token, keys)),
    }
  }


  loaders = create_loaders(request.query.auth_token)


  user = await loaders.users.load(4)
  pic = await loaders.cdn_urls.load(user.raw_pic_url)
  ```

  Creating an object where each key is a `DataLoader` is one common pattern which
  provides a single value to pass around to code which needs to perform
  data loading, such as part of the `root_value` in a [GraphQL][] request.



  Occasionally, some kind of value can be accessed in multiple ways. For example,
  perhaps a "User" type can be loaded not only by an "id" but also by a "username"
  value. If the same user is loaded by both keys, then it may be useful to fill
  both caches when a user is loaded from either source:

  ```python
  async def user_by_id_batch_fn(ids):
      users = await gen_users_by_id(ids)
      for user in users:
          username_loader.prime(user.username, user)
      return users

  user_by_id_loader = DataLoader(user_by_id_batch_fn)

  async def username_batch_fn(names):
      users = await gen_usernames(names)
      for user in users:
          user_by_id_loader.prime(user.id, user)
      return users

  username_loader = DataLoader(username_batch_fn)
  ```




  DataLoader can optionaly be provided a custom dict instance to use as its
  memoization cache. More specifically, any object that implements the methods `get()`,
  `set()`, `delete()` and `clear()` can be provided. This allows for custom dicts
  which implement various [cache algorithms][] to be provided. By default,
  DataLoader uses the standard [dict][] which simply grows until the DataLoader
  is released. The default is appropriate when requests to your application are
  short-lived.





  **DataLoader Source Code Walkthrough (YouTube):**

  <a href="https://youtu.be/OQTnXNCDywA" target="_blank" alt="DataLoader Source Code Walkthrough"><img src="https://img.youtube.com/vi/OQTnXNCDywA/0.jpg" /></a>


  [@schrockn]: https://github.com/schrockn
  [DataLoader]: https://github.com/graphql/dataloader
  [GraphQL]: https://graphql.org
  [dict]: https://docs.python.org/3/tutorial/datastructures.html#dictionaries
  [graphene]: https://github.com/graphql-python/graphene
  [graphql-core]: https://github.com/graphql-python/graphql-core
  [cache algorithms]: https://en.wikipedia.org/wiki/Cache_algorithms
  [Sanic]: https://sanic.readthedocs.io/en/latest/


pkgId: fa3ae68ecbbe5d19ac7e8a1dff41ca959b30447f784b6a28548db2e2c8ec8936
name: python-aiodataloader-ng
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Asyncio DataLoader implementation for Python
url: https://github.com/lablup/aiodataloader-ng
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiodataloader-ng-0.2.1-1.src.rpm
checksum_type: sha256
description:
  DataLoader is a generic utility to be used as part of your application's
  data fetching layer to provide a simplified and consistent API over
  various remote data sources such as databases or web services via
  batching and caching.
  |Build Status| |Coverage Status|
  A port of the "Loader" API originally developed by [@schrockn][] at
  Facebook in 2010 as a simplifying force to coalesce the sundry key-value
  store back-end APIs which existed at the time. At Facebook, "Loader"
  became one of the implementation details of the "Ent" framework, a
  privacy-aware data entity loading and caching layer within web server
  product code. This ultimately became the underpinning for Facebook's
  GraphQL server implementation and type definitions.
  DataLoader is a simplified version of this original idea implemented in
  Python for AsyncIO services. DataLoader is often used when implementing
  a `graphene <https://github.com/graphql-python/graphene>`__ service,
  though it is also broadly useful in other situations.
  DataLoader is provided so that it may be useful not just to build
  GraphQL services with AsyncIO but also as a publicly available reference
  implementation of this concept in the hopes that it can be ported to
  other languages. If you port DataLoader to another language, please open
  an issue to include a link from this repository.


pkgId: c5e8db96ee51fe6a20642c61d95dc61452a578d98cd2a7a625f9fb87b5ff549b
name: python-aioddd
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Async Python DDD utilities library.
url: https://pypi.org/project/aioddd/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioddd-1.5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/aioddd.svg)](https://badge.fury.io/py/aioddd)
  [![PyPIDownloads](https://static.pepy.tech/badge/aioddd)](https://pepy.tech/project/aioddd)
  [![CI](https://github.com/aiopy/python-aioddd/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/aiopy/python-aioddd/actions/workflows/ci.yml)

  aioddd is an async Python DDD utilities library.



  Use the package manager [pip](https://pypi.org/project/aioddd/) to install aioddd.

  ```bash
  pip install aioddd
  ```



  - Visit [aioddd docs](https://aiopy.github.io/python-aioddd/).



  ```python
  from asyncio import get_event_loop
  from dataclasses import dataclass
  from typing import Type
  from aioddd import NotFoundError, \
      Command, CommandHandler, SimpleCommandBus, \
      Query, QueryHandler, OptionalResponse, SimpleQueryBus, Event

  _products = []

  class ProductStored(Event):
      @dataclass
      class Attributes:
          ref: str

      attributes: Attributes

  class StoreProductCommand(Command):
      def __init__(self, ref: str):
          self.ref = ref

  class StoreProductCommandHandler(CommandHandler):
      def subscribed_to(self) -> Type[Command]:
          return StoreProductCommand

      async def handle(self, command: StoreProductCommand) -> None:
          _products.append(command.ref)

  class ProductNotFoundError(NotFoundError):
      _code = 'product_not_found'
      _title = 'Product not found'

  class FindProductQuery(Query):
      def __init__(self, ref: str):
          self.ref = ref

  class FindProductQueryHandler(QueryHandler):
      def subscribed_to(self) -> Type[Query]:
          return FindProductQuery

      async def handle(self, query: FindProductQuery) -> OptionalResponse:
          if query.ref != '123':
              raise ProductNotFoundError.create(detail={'ref': query.ref})
          return {'ref': query.ref}

  async def main() -> None:
      commands_bus = SimpleCommandBus([StoreProductCommandHandler()])
      await commands_bus.dispatch(StoreProductCommand('123'))
      query_bus = SimpleQueryBus([FindProductQueryHandler()])
      response = await query_bus.ask(FindProductQuery('123'))
      print(response)


  if __name__ == '__main__':
      get_event_loop().run_until_complete(main())
  ```



  - Python >= 3.9



  Pull 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.



  [MIT](https://github.com/aiopy/python-aioddd/blob/master/LICENSE)


pkgId: c0b0bb7c46cf115700f4334e7e0066c9a30cd09198a92118a18f3bd79efc45ed
name: python-aiodebug
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: A tiny library for monitoring and testing asyncio programs
url: https://gitlab.com/quantlane/libs/aiodebug
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiodebug-2.3.0-1.src.rpm
checksum_type: sha256
description:
  This is a tiny library for monitoring and testing asyncio programs.
  Its monitoring features are meant to be always on in production.


pkgId: b25304695b598e21b8663ed784846cbb6e13fdcc8169df25d732c97dc12b8faf
name: python-aiodecorators
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Function decorators based on asyncio synchronization primitives
url: http://github.com/dflupu/aiodecorators
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiodecorators-0.2.1-1.src.rpm
checksum_type: sha256
description:
  Function decorators based on asyncio Lock, Semaphore and BoundedSemaphore


  `pip3 install aiodecorators`



  [asyncio.Lock](https://docs.python.org/3/library/asyncio-sync.html#asyncio.Lock)
  ```
  from aiodecorators import Lock

  @Lock()
  async def f():
      pass
  ```

  [asyncio.Semaphore](https://docs.python.org/3/library/asyncio-sync.html#asyncio.Semaphore)
  ```
  from aiodecorators import Semaphore

  @Semaphore(n)
  async def f():
      pass
  ```
  [asyncio.BoundedSemaphore](https://docs.python.org/3/library/asyncio-sync.html#asyncio.BoundedSemaphore)
  ```
  from aiodecorators import BoundedSemaphore

  @BoundedSemaphore(n)
  async def f():
      pass
  ```


pkgId: 663540eb341775d332618cfb40999d5aa01f61d6a97099fed00dfd18eb1b231f
name: python-aiodesa
arch: src
version: 0.2.0
epoch: 0
release: 1
url: https://pypi.org/project/aiodesa/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiodesa-0.2.0-1.src.rpm
checksum_type: sha256
summary:
  AIODesa offers a straightforward and 100% Python interface for managing asynchronous data access. By leveraging Python's built-ins and standard library, it seamlessly wraps around AioSqlite, providing a hassle-free experience. With AIODesa, you can define, generate, and commit data effortlessly, thanks to shared objects for tables and records.

description:
  ![MyPy](https://img.shields.io/badge/MyPy-87.84%25-brightgreen)
  ![Pytest](https://img.shields.io/badge/Pytest-96%25-brightgreen)
  ![Code Style](https://img.shields.io/badge/Code%20Style-Black-000000)
  ![Pylint](https://img.shields.io/badge/Pylint-10/10-brightgreen)
  ![Flake8](https://img.shields.io/badge/Flake8-passed-brightgreen)
  ![Read The Docs](https://img.shields.io/badge/Documentation-0.1.12-blue)
  ![Changie Logs](https://img.shields.io/badge/Changie_logs-0.1.12-blue)








  A straightforward and 100% Python interface for managing asynchronous database API's by leveraging Python's built-ins and standard library. It wraps around AioSqlite, providing a hassle-free experience to define, generate, and commit data effortlessly, thanks to shared objects for tables and records.




  AIODesa is specifically crafted for simpler projects where database IO is minimal. It's not intended for heavy production use but rather serves as an excellent choice for personal projects that require SQL structured data persistence without the complexity of a full-scale database setup. SQLite is leveraged here, meaning youre free to use other SQLite drivers to consume and transform the data if your project outgrows AIODesa.




  ![AIODesa](https://github.com/sockheadrps/AIODesa/raw/main/desa.png?raw=true)




  __Install via pip__
  ```
  pip install aiodesa
  ```

  Sample API usage:

  ```python
  from aiodesa import Db
  import asyncio
  from dataclasses import dataclass
  from aiodesa.utils.tables import ForeignKey, UniqueKey, PrimaryKey, set_key


  async def main():
  	
  	
  	@dataclass
  	@set_key(PrimaryKey("username"), UniqueKey("id"), ForeignKey("username", "anothertable"))
  	class UserEcon:
  		username: str
  		credits: int | None = None
  		points: int | None = None
  		id: str | None = None
  		table_name: str = "user_economy"


  	async with Db("database.sqlite3") as db:
  		
  		await db.read_table_schemas(UserEcon)

  		
  		record = db.insert(UserEcon)
  		await record('sockheadrps', id="fffff")

  		
  		record = db.update(UserEcon, column_identifier="username")
  		await record('sockheadrps', points=2330, id="1234")

  		
  		find_all_users = db.find_all(UserEcon)
  		all_users = await find_all_users()
  		for user in all_users:
  			print(user.username)

  asyncio.run(main())

  ```

  <br>



  Ensure poetry is installed:

  ```
  pip install poetry
  ```

  Install project using poetry

  ```
  poetry add git+https://github.com/sockheadrps/AIODesa.git
  poetry install
  ```

  create a python file for using AIODesa and activate poetry virtual env to run it

  ```
  poetry shell
  poetry run python main.py
  ```


pkgId: ec57dca3e03b9cc38c057bd096e26553c8eedec25955c28f1f8250d8c9824533
name: python-aiodhcpwatcher
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Watch for DHCP packets with asyncio
url: https://github.com/bdraco/aiodhcpwatcher
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiodhcpwatcher-1.0.2-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://aiodhcpwatcher.readthedocs.io" target="_blank">https://aiodhcpwatcher.readthedocs.io </a>


pkgId: 7ae6b6e078de2a400f6e612fe19f09f3f335320061aa8df0118b5ed3ae263487
name: python-aiodiscover
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Discover hosts by arp and ptr lookup
url: https://github.com/uilibs/aiodiscover
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiodiscover-2.2.0-1.src.rpm
checksum_type: sha256
description:
  - Discover hosts on the network via ARP and PTR lookup

  ```python
  import asyncio
  import pprint
  from aiodiscover import DiscoverHosts
  discover_hosts = DiscoverHosts()
  hosts = asyncio.run(discover_hosts.async_discover())
  pprint.pprint(hosts)
  ```

  **Stable Release:** `pip install aiodiscover`<br>
  **Development Head:** `pip install git+https://github.com/bdraco/aiodiscover.git`

  For full package documentation please visit [bdraco.github.io/aiodiscover](https://bdraco.github.io/aiodiscover).

  See [CONTRIBUTING.md](CONTRIBUTING.md) for information related to developing the code.

  1. `pip install -e .[dev]`
     This will install your package in editable mode with all the required development
     dependencies (i.e. `tox`).
  2. `make build`
     This will run `tox` which will run all your tests in both Python 3.7
     and Python 3.8 as well as linting your code.
  3. `make clean`
     This will clean up various Python and build generated files so that you can ensure
     that you are working in a clean environment.
  4. `make docs`
     This will generate and launch a web browser to view the most up-to-date
     documentation for your Python package.

  - Turn your project into a GitHub repository:
    - Make an account on [github.com](https://github.com)
    - Go to [make a new repository](https://github.com/new)
    - _Recommendations:_
      - _It is strongly recommended to make the repository name the same as the Python
        package name_
      - _A lot of the following optional steps are *free* if the repository is Public,
        plus open source is cool_
    - After a GitHub repo has been created, run the commands listed under:
      "...or push an existing repository from the command line"
  - Register your project with Codecov:
    - Make an account on [codecov.io](https://codecov.io)(Recommended to sign in with GitHub)
      everything else will be handled for you.
  - Ensure that you have set GitHub pages to build the `gh-pages` branch by selecting the
    `gh-pages` branch in the dropdown in the "GitHub Pages" section of the repository settings.
    ([Repo Settings](https://github.com/bdraco/aiodiscover/settings))
  - Register your project with PyPI:
    - Make an account on [pypi.org](https://pypi.org)
    - Go to your GitHub repository's settings and under the
      [Secrets tab](https://github.com/bdraco/aiodiscover/settings/secrets/actions),
      add a secret called `PYPI_TOKEN` with your password for your PyPI account.
      Don't worry, no one will see this password because it will be encrypted.
    - Next time you push to the branch `main` after using `bump2version`, GitHub
      actions will build and deploy your Python package to PyPI.

  1. `main` is for the most up-to-date development, very rarely should you directly
     commit to this branch. GitHub Actions will run on every push and on a CRON to this
     branch but still recommended to commit to your development branches and make pull
     requests to main. If you push a tagged commit with bumpversion, this will also release to PyPI.
  2. Your day-to-day work should exist on branches separate from `main`. Even if it is
     just yourself working on the repository, make a PR from your working branch to `main`
     so that you can ensure your commits don't break the development head. GitHub Actions
     will run on every push to any branch or any pull request from any branch to any other
     branch.
  3. It is recommended to use "Squash and Merge" commits when committing PR's. It makes
     each set of changes to `main` atomic and as a side effect naturally encourages small
     well defined PR's.
  **Apache Software License 2.0**


pkgId: c10c919ce77470e2a815223b6d8f85ebdd64b361a0700b11118c3c621a2cf1b9
name: python-aiodnsresolver
arch: src
version: 0.0.155
epoch: 0
release: 1
summary: Pure asyncio Python DNS resolver
url: https://github.com/michalc/aiodnsresolver
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiodnsresolver-0.0.155-1.src.rpm
checksum_type: sha256
description:
  [![PyPI package](https://img.shields.io/pypi/v/aiodnsresolver?label=PyPI%20package&color=%234c1)](https://pypi.org/project/aiodnsresolver/) [![Test suite](https://img.shields.io/github/actions/workflow/status/michalc/aiodnsresolver/test.yml?label=Test%20suite)](https://github.com/michalc/aiodnsresolver/actions/workflows/test.yml) [![Code coverage](https://img.shields.io/codecov/c/github/michalc/aiodnsresolver?label=Code%20coverage)](https://app.codecov.io/gh/michalc/aiodnsresolver)

  Asyncio Python DNS resolver. Pure Python, with no dependencies other than the standard library, threads are not used, no additional tasks are created, and all code is in a single module. The nameservers to query are taken from `/etc/resolv.conf`, and treats hosts in `/etc/hosts` as A or AAAA records with a TTL of 0.

  Designed for highly concurrent/HA situations. Based on https://github.com/gera2ld/async_dns.




  ```bash
  pip install aiodnsresolver
  ```




  ```python
  from aiodnsresolver import Resolver, TYPES

  resolve, _ = Resolver()
  ip_addresses = await resolve('www.google.com', TYPES.A)
  ```

  Returned are tuples of subclasses of [IPv4Address](https://docs.python.org/3/library/ipaddress.html#ipaddress.IPv4Address) or [IPv6Address](https://docs.python.org/3/library/ipaddress.html#ipaddress.IPv6Address). Both support conversion to their usual string form by passing them to `str`.




  A cache is part of each `Resolver()`, expiring records automatically according to their TTL.

  ```python
  import asyncio
  from aiodnsresolver import Resolver, TYPES

  resolve, clear_cache = Resolver()


  ip_addresses = await resolve('www.google.com', TYPES.A)


  ip_addresses = await resolve('www.google.com', TYPES.A)

  await clear_cache()

  ip_addresses = await resolve('www.google.com', TYPES.A)
  ```

  The cache for each record starts on the _start_ of each request, so duplicate concurrent requests for the same record are not made.




  The address objects each have an extra property, `expires_at`, that returns the expiry time of the address, according to the `loop.time()` clock, and the TTL of the records involved to find that address.

  ```python
  import asyncio
  from aiodnsresolver import Resolver, TYPES

  resolve, _ = Resolver()
  ip_addresses = await resolve('www.google.com', TYPES.A)

  loop = asyncio.get_event_loop()
  for ip_address in ip_address:
      print('TTL',  max(0.0, ip_address.expires_at - loop.time())
  ```

  This can be used in HA situations to assist failovers. The timer for `expires_at` starts just _before_ the request to the nameserver is made.




  CNAME records are followed transparently. The `expires_at` of IP addresses found via intermediate CNAME(s) is determined by using the minimum `expires_at` of all the records involved in determining those IP addresses.




  It is possible to query nameservers other than those in `/etc/resolv.conf`, and for each to specify a timeout in seconds to wait for a reply before querying the next.

  ```python
  async def get_nameservers(_, __):
      yield (0.5, ('8.8.8.8', 53))
      yield (0.5, ('1.1.1.1', 53))
      yield (1.0, ('8.8.8.8', 53))
      yield (1.0, ('1.1.1.1', 53))

  resolve, _ = Resolver(get_nameservers=get_nameservers)
  ip_addresses = await resolve('www.google.com', TYPES.A)
  ```

  Parallel requests to multiple nameservers are also possible, where the first response from each set of requests is used.

  ```python
  async def get_nameservers(_, __):
      
      
      yield (0.5, ('8.8.8.8', 53), ('1.1.1.1', 53))
      
      yield (1.0, ('8.8.8.8', 53), ('1.1.1.1', 53))

  resolve, _ = Resolver(get_nameservers=get_nameservers)
  ip_addresses = await resolve('www.google.com', TYPES.A)
  ```

  This can be used as part of a HA system: if a nameserver isn't contactable, this pattern avoids waiting for its timeout before querying another nameserver.




  It's possible to specify hosts without editing the `/etc/hosts` file.

  ```python
  from aiodnsresolver import Resolver, IPv4AddressExpiresAt, TYPES

  async def get_host(_, fqdn, qtype):
      hosts = {
          b'localhost': {
              TYPES.A: IPv4AddressExpiresAt('127.0.0.1', expires_at=0),
          },
          b'example.com': {
              TYPES.A: IPv4AddressExpiresAt('127.0.0.1', expires_at=0),
          },
      }
      try:
          return hosts[qtype][fqdn]
      except KeyError:
          return None

  resolve, _ = Resolver(get_host=get_host)
  ip_addresses = await resolve('www.google.com', TYPES.A)
  ```




  Exceptions are subclasses of `DnsError`, and are raised if a record does not exist, on socket errors, timeouts, message parsing errors, or other errors returned from the nameserver.

  Specifically, if a record is determined to not exist, `DnsRecordDoesNotExist` is raised.


  ```python
  from aiodnsresolver import Resolver, TYPES, DnsRecordDoesNotExist, DnsError

  resolve, _ = Resolver()
  try:
      ip_addresses = await resolve('www.google.com', TYPES.A)
  except DnsRecordDoesNotExist:
      print('domain does not exist')
      raise
  except DnsError as exception:
      print(type(exception))
      raise
  ```

  If a lower-level exception caused the `DnsError`, it will be in the `__cause__` attribute of the exception.




  By default logging is through the `Logger` named `aiodnsresolver`, and all messages are prefixed with `[dns]` or `[dns:<fqdn>,<query-type>]` through a `LoggerAdapter`. Each function accepts `get_logger_adapter`: the default of which results in this behaviour, and can be overridden to set either the `Logger` or the `LoggerAdapter`.


  ```python
  import logging
  from aiodnsresolver import Resolver, ResolverLoggerAdapter

  resolve, clear_cache = Resolver(
      get_logger_adapter=lambda extra: ResolverLoggerAdapter(logging.getLogger('my-application.dns'), extra),
  )
  ```

  The `LoggerAdapter` used by `resolve` and `clear_cache` defaults to the one passed to `Resolver`.




  For complex or highly concurrent applications, it may be desirable that logging adapters be chained to output log messages that incorporate a parent context. So the default ouput of

  ```
  [dns:my-domain.com,A] Concurrent request found, waiting for it to complete
  ```

  would be prefixed with a _parent_ context to output something like

  ```
  [request:12345] [dns:my-domain.com,A] Concurrent request found, waiting for it to complete
  ```

  To do this, set `get_logger_adapter` as a function that chains multiple `LoggerAdapter`.

  ```python
  import logging
  from aiodnsresolver import Resolver, TYPES, ResolverLoggerAdapter

  class RequestAdapter(logging.LoggerAdapter):
      def process(self, msg, kwargs):
          return '[request:%s] %s' % (self.extra['request-id'], msg), kwargs

  def get_logger_adapter(extra):
      parent_adapter = RequestAdapter(logging.getLogger('my-application.dns'), {'request-id': '12345'})
      child_adapter = ResolverLoggerAdapter(parent_adapter, extra)
      return child_adapter

  resolve, _ = Resolver()
  result = await resolve('www.google.com', TYPES.A, get_logger_adapter=get_logger_adapter)
  ```




  A maximum of two messages per DNS query are logged at `INFO`. If a nameserver fails, a `WARNING` is issued [although an exception will be raised if no nameservers succeed], and the remainder of messages are logged at `DEBUG`. No `ERROR` or `CRITICAL` messages are issued when exceptions are raised: it is the responsiblity of client code to log these if desired.




  By default each domain name is encoded with [0x20-bit encoding](https://astrolavos.gatech.edu/articles/increased_dns_resistance.pdf) before being sent to the nameservers. However, some nameservers, such as Docker's built-in, do not support this. So, to control or disable the encoding, you can pass a custom `transform_fqdn` coroutine to Resolver that does not perform any additional encoding.

  ```python
  from aiodnsresolver import Resolver

  async def transform_fqdn_no_0x20_encoding(fqdn):
      return fqdn

  resolve, _ = Resolver(transform_fqdn=transform_fqdn_no_0x20_encoding)
  ```

  or performs it conditionally

  ```python
  from aiodnsresolver import Resolver, mix_case

  async def transform_fqdn_0x20_encoding_conditionally(fqdn):
      return \
          fqdn if fqdn.endswith(b'some-domain') else \
          await mix_case(fqdn)

  resolve, _ = Resolver(transform_fqdn=transform_fqdn_0x20_encoding_conditionally)
  ```



  To migitate spoofing, several techniques are used.

  - Each query is given a random ID, which is checked against any response.

  - By default each domain name is encoded with [0x20-bit encoding](https://astrolavos.gatech.edu/articles/increased_dns_resistance.pdf), which is checked against any response.

  - A new socket, and so a new random local port, is used for each query.

  - Requests made for a domain while there is an in-flight query for that domain, wait for the the in-flight query to finish, and use its result.

  Also, to migitate the risk of evil responses/configuration

  - [Pointer loops](https://nvd.nist.gov/vuln/detail/CVE-2017-2909) are detected.

  - CNAME chains have a maximum length.




  No tasks are created, and the event loop is only yielded to during socket communication. Because fetching results from the cache involves no socket communication, this means that cached results are fetched without yielding. This introduces a small inconsistency between fetching cached and non-cached results, and so clients should be written to not depend on the presence or lack of a yield during resolution. This is a typically recommended process however: it should be expected that coroutines might yield.

  The trade-off for this inconsistency is that cached results are fetched slightly faster than if resolving were to yield in all cases.

  For CNAME chains, the event loop is yielded during each communication for non-cached parts of the chain.




  The scope of this project is deliberately restricted to operations that are used to resolve A or AAAA records: to resolve a domain name to its IP addresses so that IP connections can be made, and have similar responsibilities to `gethostbyname`. Some limited extra behaviour is present/may be added, but great care is taken to prevent scope creep, especially to not add complexity that isn't required to resolve A or AAAA records.

  - UDP queries are made, but not TCP. DNS servers must support UDP, and it's impossible for a single A and AAAA record to not fit into the maximum size of a UDP DNS response, 512 bytes. There may be other data that the DNS server would return in TCP connections, but this isn't required to resolve a domain name to a single IP address.

    It is technically possible that in the case of extremely high numbers of A or AAAA records for a domain, they would not fit in a single UDP message. However, this is extremely unlikely, and in this unlikely case, extremely unlikely to affect target applications in any meaningful way. If a truncated message is received, a warning is logged.

  - The resolver is a _stub_ resolver: it delegates the responsibility of recursion to the nameserver(s) it queries. In the vast majority of envisioned use cases this is acceptable, since the nameservers in `/etc/resolv.conf` will be recursive.




  ```python
  import asyncio
  import socket

  from aiodnsresolver import (
      TYPES,
      Resolver,
      DnsError,
      DnsRecordDoesNotExist,
  )
  import aiohttp


  class AioHttpDnsResolver(aiohttp.abc.AbstractResolver):
      def __init__(self):
          super().__init__()
          self.resolver, self.clear_cache = Resolver()

      async def resolve(self, host, port=0, family=socket.AF_INET):
          
          
          record_type = \
              TYPES.AAAA if family == socket.AF_INET6 else \
              TYPES.A

          try:
              ip_addresses = await self.resolver(host, record_type)
          except DnsRecordDoesNotExist as does_not_exist:
              raise OSError(0, '{} does not exist'.format(host)) from does_not_exist
          except DnsError as dns_error:
              raise OSError(0, '{} failed to resolve'.format(host)) from dns_error

          return [{
              'hostname': host,
              'host': str(ip_address),
              'port': port,
              'family': family,
              'proto': socket.IPPROTO_TCP,
              'flags': socket.AI_NUMERICHOST,
          } for ip_address in ip_addresses]

      async def close(self):
          await self.clear_cache()


  async def main():
      async with aiohttp.ClientSession(
          connector=aiohttp.TCPConnector(use_dns_cache=False, resolver=AioHttpDnsResolver()),
      ) as session:
          async with await session.get('https://www.google.com/') as result:
              print(result)

  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())
  loop.close()
  ```




  ```python
  import asyncio
  import socket

  from aiodnsresolver import (
      TYPES,
      DnsError,
      DnsRecordDoesNotExist,
      Resolver,
  )

  import tornado.httpclient
  import tornado.netutil

  class AioHttpDnsResolver(tornado.netutil.Resolver):
      def initialize(self):
          self.resolver, self.clear_cache = Resolver()

      async def resolve(self, host, port=0, family=socket.AF_UNSPEC):
          
          record_type, family_conn = \
              (TYPES.AAAA, socket.AF_INET6) if family == socket.AF_INET6 else \
              (TYPES.A, socket.AF_INET)

          try:
              ip_addresses = await self.resolver(host, record_type)
          except DnsRecordDoesNotExist as does_not_exist:
              raise IOError('{} does not exist'.format(host)) from does_not_exist
          except DnsError as dns_error:
              raise IOError('{} failed to resolve'.format(host)) from dns_error

          return [
              (family_conn, (str(ip_address), port))
              for ip_address in ip_addresses
          ]

      async def close(self):
          await self.clear_cache()

  async def main():
      tornado.netutil.Resolver.configure(AioHttpDnsResolver)
      http_client = tornado.httpclient.AsyncHTTPClient()
      response = await http_client.fetch("http://www.google.com")
      print(response.body)

  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())
  loop.close()
  ```




  No extra code is needed to use aiodnsresolver with [lowhaio](https://github.com/michalc/lowhaio): it is used by default.




  Tests attempt to closly match real-world use, and assert on how input translate to output, i.e. the _public_ behaviour of the resolver. Therefore the tests avoid assumptions on implementation details.

  There are however exceptions.

  Many tests assume that timeouts are controlled by `asyncio.sleep`, `loop.call_later` or `loop.call_at`. This is to allow time to be fast-forwarded through cache invalidation using [aiofastforward](https://github.com/michalc/aiofastforward) without actually having to wait the corresponding time in the tests. Also, many tests assume `open` is used to access files, and patch it to allow assertions on what the code would do with different contents of `/etc/resolv.conf` or `/etc/hosts`.

  While both being assumptions, they are both unlikely to change, and in the case that they are changed, this would much more likely result in tests failing incorrectly rather than passing incorrectly. Therefore these are low-risk assumptions.

  A higher risk assumption is that many tests use the, otherwise private, `pack` and `parse` functions as part of the built-in DNS server that is used by the tests. These are the core functions used by the production code used to pack and parse DNS messages. While asserting that the resolver can communicate to the built-in nameserver, all the tests do is assert that `pack` and `parse` are consistent with each other: it is an assumption that other nameservers have equivalent behaviour.

  To mitigate the risks that these assumptions bring, some "end to end"-style tests are included, which use whatever nameservers are in `/etc/resolv.conf`, and asserting on globally available DNS results. While not going through every possible case of input, they do validate that core behaviour is consistent with one other implementation of the protocol.


pkgId: ce3e8e9e50fedf402bc5894afeac20de3a2c774e707254fa5c49c4aa6854bce5
name: python-aiodogstatsd
arch: src
version: 0.16.0.post0
epoch: 0
release: 1
summary: An asyncio-based client for sending metrics to StatsD with support of DogStatsD extension
url: https://github.com/Gr1N/aiodogstatsd
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiodogstatsd-0.16.0.post0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/Gr1N/aiodogstatsd/workflows/default/badge.svg)](https://github.com/Gr1N/aiodogstatsd/actions?query=workflow%3Adefault) [![codecov](https://codecov.io/gh/Gr1N/aiodogstatsd/branch/master/graph/badge.svg)](https://codecov.io/gh/Gr1N/aiodogstatsd) ![PyPI](https://img.shields.io/pypi/v/aiodogstatsd.svg?label=pypi%20version) ![PyPI - Downloads](https://img.shields.io/pypi/dm/aiodogstatsd.svg?label=pypi%20downloads) ![GitHub](https://img.shields.io/github/license/Gr1N/aiodogstatsd.svg)

  An asyncio-based client for sending metrics to StatsD with support of [DogStatsD](https://docs.datadoghq.com/developers/dogstatsd/) extension.

  Library fully tested with [statsd_exporter](https://github.com/prometheus/statsd_exporter) and supports `gauge`, `counter`, `histogram`, `distribution` and `timing` types.

  `aiodogstatsd` client by default uses _9125_ port. It's a default port for [statsd_exporter](https://github.com/prometheus/statsd_exporter) and it's different from _8125_ which is used by default in StatsD and [DataDog](https://www.datadoghq.com/). Initialize the client with the proper port you need if it's different from _9125_.



  Just type:

  ```sh
  $ pip install aiodogstatsd
  ```



  Just simply use client as a context manager and send any metric you want:

  ```python
  import asyncio

  import aiodogstatsd


  async def main():
      async with aiodogstatsd.Client() as client:
          client.increment("users.online")


  asyncio.run(main())
  ```

  Please follow [documentation](https://gr1n.github.io/aiodogstatsd) or look at [`examples/`](https://github.com/Gr1N/aiodogstatsd/tree/master/examples) directory to find more examples of library usage, e.g. integration with [`AIOHTTP`](https://aiohttp.readthedocs.io/) or [`Starlette`](https://www.starlette.io) frameworks.



  To work on the `aiodogstatsd` codebase, you'll want to clone the project locally and install the required dependencies via [poetry](https://poetry.eustace.io):

  ```sh
  $ git clone git@github.com:Gr1N/aiodogstatsd.git
  $ make install
  ```

  To run tests and linters use command below:

  ```sh
  $ make lint && make test
  ```

  If you want to run only tests or linters you can explicitly specify which test environment you want to run, e.g.:

  ```sh
  $ make lint-black
  ```



  `aiodogstatsd` is licensed under the MIT license. See the license file for details.


pkgId: 5187882a7366196bc6b89e1470a5f26c17535dd80267db5f657b6804c7ec527c
name: python-aiodynamo
arch: src
version: 24.7
epoch: 0
release: 1
summary: Asyncio DynamoDB client
url: https://github.com/HENNGE/aiodynamo
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiodynamo-24.7-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/HENNGE/aiodynamo.svg?style=svg)](https://circleci.com/gh/HENNGE/aiodynamo)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Documentation Status](https://readthedocs.org/projects/aiodynamo/badge/?version=latest)](https://aiodynamo.readthedocs.io/en/latest/?badge=latest)

  Asynchronous pythonic DynamoDB client; **2x** faster than `aiobotocore/boto3/botocore`.




  Install this library

  `pip install "aiodynamo[httpx]"` or, for poetry users `poetry add aiodynamo -E httpx`

  Connect to DynamoDB

  ```py
  from aiodynamo.client import Client
  from aiodynamo.credentials import Credentials
  from aiodynamo.http.httpx import HTTPX
  from httpx import AsyncClient

  async def main():
      async with AsyncClient() as h:
          client = Client(HTTPX(h), Credentials.auto(), "us-east-1")
  ```


  Install this library

  `pip install "aiodynamo[aiohttp]"` or, for poetry users `poetry add aiodynamo -E aiohttp`

  Connect to DynamoDB

  ```py
  from aiodynamo.client import Client
  from aiodynamo.credentials import Credentials
  from aiodynamo.http.aiohttp import AIOHTTP
  from aiohttp import ClientSession

  async def main():
      async with ClientSession() as session:
          client = Client(AIOHTTP(session), Credentials.auto(), "us-east-1")
  ```



  ```py
  from aiodynamo.client import Client
  from aiodynamo.expressions import F
  from aiodynamo.models import Throughput, KeySchema, KeySpec, KeyType

  async def main(client: Client):
      table = client.table("my-table")

      
      if not await table.exists():
          await table.create(
              Throughput(read=10, write=10),
              KeySchema(hash_key=KeySpec("key", KeyType.string)),
          )

      
      await table.put_item({"key": "my-item", "value": 1})
      
      item = await table.get_item({"key": "my-item"})
      print(item)
      
      await table.update_item(
          {"key": "my-item"}, F("value").add(1), condition=F("key").exists()
      )
  ```



  * boto3 and botocore are synchronous. aiodynamo is built for **asynchronous** apps.
  * aiodynamo is **fast**. Two times faster than aiobotocore, botocore or boto3 for operations such as query or scan.
  * aiobotocore is very low level. aiodynamo provides a **pythonic API**, using modern Python features. For example, paginated APIs are automatically depaginated using asynchronous iterators.
  * **Legible source code**. botocore and derived libraries generate their interface at runtime, so it cannot be inspected and isn't typed. aiodynamo is hand written code you can read, inspect and understand.
  * **Pluggable HTTP client**. If you're already using an asynchronous HTTP client in your project, you can use it with aiodynamo and don't need to add extra dependencies or run into dependency resolution issues.

  [Complete documentation is here](https://aiodynamo.readthedocs.io/)


pkgId: cfb213a8f6d18165e95be303e898dbce51cceeb45be73e7e83b9d1abe508e92a
name: python-aioeagle
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Python module to talk to Rainforest EAGLE-200.
url: https://github.com/home-assistant-libs/aioeagle
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioeagle-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Requires Python 3.8+ and uses asyncio and aiohttp.

  ```python
  import asyncio
  from pprint import pprint

  import aiohttp
  from aioeagle import EagleHub


  CLOUD_ID = "123456"
  INSTALL_CODE = "abcdefghijklmn"


  async def main():
      async with aiohttp.ClientSession() as session:
          await run(session)


  async def run(websession):
      hub = EagleHub(websession, CLOUD_ID, INSTALL_CODE)
      devices = await hub.get_device_list()

      if len(devices) == 0:
          print("No devices found")
          return

      device = devices[0]

      pprint(device.details)
      print()
      pprint(await device.get_device_query(device.ENERGY_AND_POWER_VARIABLES))


  asyncio.run(main())
  ```



  ```bash
  python3 example.py <cloud_id> <install_code>
  ```



  Aioeagle does not specify any timeouts for any requests. You will need to specify them in your own code. We recommend the `async_timeout` package:

  ```python
  import async_timeout

  with async_timeout.timeout(10):
      devices = await hub.get_device_list()
  ```



  Object hierarchy and property/method names should match the EAGLE-200 API.


pkgId: 95b5c9a76b7e21fb46edd875303ad355a087d2a106eb456df1c8789ce78a175f
name: python-aioec
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: async client library for the Emote Collector API
url: https://github.com/EmoteCollector/aioec
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioec-0.6.2-1.src.rpm
checksum_type: sha256
description:
  An aiohttp-based client for the `Emote Collector API <https://emote-collector.python-for.life/api/v0/docs>`_.


pkgId: 25b2c0a0cf445fed326840b3b235e74a464d52a1b095599ca6b6cd230ac7a22a
name: python-aioecopanel
arch: src
version: 0.0.14
epoch: 0
release: 1
summary: A package to be used for the Home Assistant Bepacom Integration for displaying BACnet devices.
url: https://github.com/pypa/sampleproject
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioecopanel-0.0.14-1.src.rpm
checksum_type: sha256
description:
  This is a library created for communicating with the Bepacom EcoPanel BACnet add-on for Home Assistant.
  This library contains the possibility to interact with the add-on through GET and POST requests, as well as through a websocket.


pkgId: 119a307f87eb642540675a894a46b69a4fe3f2bf1f7946d56e8aab110988dc64
name: python-aioelectricitymaps
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Async Python 3 wrapper for Electricity maps
url: https://github.com/jpbede/aioelectricitymaps
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioelectricitymaps-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Release][releases-shield]][releases]
  [![Python Versions][python-versions-shield]][pypi]
  ![Project Stage][project-stage-shield]
  ![Project Maintenance][maintenance-shield]
  [![License][license-shield]](LICENSE.md)

  [![Build Status][build-shield]][build]
  [![Code Coverage][codecov-shield]][codecov]

  Asynchronous Python client for Electricity Maps.



  This package allows you to fetch data from electricitymaps.com.



  ```bash
  pip install aioelectricitymaps
  ```



  ```python
  import asyncio

  from aioelectricitymaps import ElectricityMaps, ZoneRequest


  async def main() -> None:
      """Run the example."""
      async with ElectricityMaps(token="abc123") as em:
          response = await em.latest_carbon_intensity(ZoneRequest("DE"))

          print(f"Carbon intensity in Germany: {response.carbon_intensity} gCO2eq/kWh")


  if __name__ == "__main__":
      asyncio.run(main())
  ```



  This repository keeps a change log using [GitHub's releases][releases]
  functionality. The format of the log is based on
  [Keep a Changelog][keepchangelog].

  Releases are based on [Semantic Versioning][semver], and use the format
  of `MAJOR.MINOR.PATCH`. In a nutshell, the version will be incremented
  based on the following:

  - `MAJOR`: Incompatible or major changes.
  - `MINOR`: Backwards-compatible new features and enhancements.
  - `PATCH`: Backwards-compatible bugfixes and package updates.



  This is an active open-source project. I am always open to people who want to
  use the code or contribute to it.

  Thank you for being involved! :heart_eyes:



  This Python project is fully managed using the [Poetry][poetry] dependency manager. But also relies on the use of NodeJS for certain checks during development.

  You need at least:

  - Python 3.11+
  - [Poetry][poetry-install]
  - NodeJS 20+ (including NPM)

  To install all packages, including all development requirements:

  ```bash
  npm install
  poetry install
  ```

  As this repository uses the [pre-commit][pre-commit] framework, all changes
  are linted and tested with each commit. You can run all checks and tests
  manually, using the following command:

  ```bash
  poetry run pre-commit run --all-files
  ```

  To run just the Python tests:

  ```bash
  poetry run pytest
  ```



  The content is by [Jan-Philipp Benecke][jpbede].

  For a full list of all authors and contributors,
  check [the contributor's page][contributors].



  MIT License

  Copyright (c) 2023 Jan-Philipp Benecke

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.

  [build-shield]: https://github.com/jpbede/aioelectricitymaps/actions/workflows/release.yml/badge.svg
  [build]: https://github.com/jpbede/aioelectricitymaps/actions
  [codecov-shield]: https://codecov.io/gh/jpbede/aioelectricitymaps/branch/master/graph/badge.svg
  [codecov]: https://codecov.io/gh/jpbede/aioelectricitymaps
  [commits-shield]: https://img.shields.io/github/commit-activity/y/jpbede/aioelectricitymaps.svg
  [commits]: https://github.com/jpbede/aioelectricitymaps/commits/main
  [contributors]: https://github.com/jpbede/aioelectricitymaps/graphs/contributors
  [jpbede]: https://github.com/jpbede
  [keepchangelog]: http://keepachangelog.com/en/1.0.0/
  [license-shield]: https://img.shields.io/github/license/jpbede/aioelectricitymaps.svg
  [maintenance-shield]: https://img.shields.io/maintenance/yes/2024.svg
  [poetry-install]: https://python-poetry.org/docs/#installation
  [poetry]: https://python-poetry.org
  [pre-commit]: https://pre-commit.com/
  [project-stage-shield]: https://img.shields.io/badge/project%20stage-stable-green.svg
  [python-versions-shield]: https://img.shields.io/pypi/pyversions/aioelectricitymaps
  [releases-shield]: https://img.shields.io/github/release/jpbede/aioelectricitymaps.svg
  [releases]: https://github.com/jpbede/aioelectricitymaps/releases
  [semver]: http://semver.org/spec/v2.0.0.html
  [pypi]: https://pypi.org/project/aioelectricitymaps/


pkgId: bc131bf8d731b1c149d264f4ced5e75043b47790f9df21df88f5ccebc551f18b
name: python-aioemonitor
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Asyncio Python lib for SiteSage Emonitor
url: https://github.com/bdraco/aioemonitor
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioemonitor-1.0.5-1.src.rpm
checksum_type: sha256
description:
  -   Retreive emonitor power status

  ```python
  import asyncio
  import pprint
  from aioemonitor import Emonitor
  from aiohttp import ClientSession
  async def run():
      session = ClientSession()
      emonitor = Emonitor("1.2.3.4", session)
      status = await emonitor.async_get_status()
      pprint.pprint(status)
  asyncio.run(run())
  ```

  **Stable Release:** `pip install aioemonitor`<br>
  **Development Head:** `pip install git+https://github.com/bdraco/aioemonitor.git`

  For full package documentation please visit [bdraco.github.io/aioemonitor](https://bdraco.github.io/aioemonitor).

  See [CONTRIBUTING.md](CONTRIBUTING.md) for information related to developing the code.

  1. `pip install -e .[dev]`
      This will install your package in editable mode with all the required development
      dependencies (i.e. `tox`).
  2. `make build`
      This will run `tox` which will run all your tests in both Python 3.7
      and Python 3.8 as well as linting your code.
  3. `make clean`
      This will clean up various Python and build generated files so that you can ensure
      that you are working in a clean environment.
  4. `make docs`
      This will generate and launch a web browser to view the most up-to-date
      documentation for your Python package.

  -   Turn your project into a GitHub repository:
      -   Make an account on [github.com](https://github.com)
      -   Go to [make a new repository](https://github.com/new)
      -   _Recommendations:_
          -   _It is strongly recommended to make the repository name the same as the Python
              package name_
          -   _A lot of the following optional steps are *free* if the repository is Public,
              plus open source is cool_
      -   After a GitHub repo has been created, run the commands listed under:
          "...or push an existing repository from the command line"
  -   Register your project with Codecov:
      -   Make an account on [codecov.io](https://codecov.io)(Recommended to sign in with GitHub)
          everything else will be handled for you.
  -   Ensure that you have set GitHub pages to build the `gh-pages` branch by selecting the
      `gh-pages` branch in the dropdown in the "GitHub Pages" section of the repository settings.
      ([Repo Settings](https://github.com/bdraco/aioemonitor/settings))
  -   Register your project with PyPI:
      -   Make an account on [pypi.org](https://pypi.org)
      -   Go to your GitHub repository's settings and under the
          [Secrets tab](https://github.com/bdraco/aioemonitor/settings/secrets/actions),
          add a secret called `PYPI_TOKEN` with your password for your PyPI account.
          Don't worry, no one will see this password because it will be encrypted.
      -   Next time you push to the branch `main` after using `bump2version`, GitHub
          actions will build and deploy your Python package to PyPI.

  1. `main` is for the most up-to-date development, very rarely should you directly
     commit to this branch. GitHub Actions will run on every push and on a CRON to this
     branch but still recommended to commit to your development branches and make pull
     requests to main. If you push a tagged commit with bumpversion, this will also release to PyPI.
  2. Your day-to-day work should exist on branches separate from `main`. Even if it is
     just yourself working on the repository, make a PR from your working branch to `main`
     so that you can ensure your commits don't break the development head. GitHub Actions
     will run on every push to any branch or any pull request from any branch to any other
     branch.
  3. It is recommended to use "Squash and Merge" commits when committing PR's. It makes
     each set of changes to `main` atomic and as a side effect naturally encourages small
     well defined PR's.
  **Apache Software License 2.0**


pkgId: 6f582a9fefb3ac3bd1b6d1911caf77a783a3cfe0bfd17299d71f5834381f9c78
name: python-aioesphomeapi
arch: src
version: 27.0.1
epoch: 0
release: 1
summary: Python API for interacting with ESPHome devices.
url: https://esphome.io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioesphomeapi-27.0.1-1.src.rpm
checksum_type: sha256
description:
  ``aioesphomeapi`` allows you to interact with devices flashed with `ESPHome <https://esphome.io/>`_.


pkgId: 9e1794ee75f4756666ea1d51f9a53a52de8162a645511987179280a2608fd3be
name: python-aioeufyclean
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Async library for Jellyfin
url: https://pypi.org/project/aioeufyclean/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioeufyclean-0.5.1-1.src.rpm
checksum_type: sha256
description:
  This is a support library for controlling eufy robot vacuum cleaners over a local network connection.

  This library is tested with a eufy Clean X8.



  This wouldn't be possible without the work by Richard Mitchell (see https://github.com/mitchellrj/eufy_robovac) and its many forks. Thanks!


pkgId: 653749517da88189a2f6ae31e4c5eda9d0d91ff03672b02e5424c2563a241689
name: python-aioextensions
arch: src
version: 21.7.2261349
epoch: 0
release: 1
summary: High performance functions to work with the async IO
url: https://fluidattacks.github.io/aioextensions
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioextensions-21.7.2261349-1.src.rpm
checksum_type: sha256
description:
  [![Release](
  https://img.shields.io/pypi/v/aioextensions?color=success&label=Release&style=flat-square)](
  https://pypi.org/project/aioextensions)
  [![Documentation](
  https://img.shields.io/badge/Documentation-click_here!-success?style=flat-square)](
  https://fluidattacks.github.io/aioextensions/)
  [![Downloads](
  https://img.shields.io/pypi/dm/aioextensions?label=Downloads&style=flat-square)](
  https://pypi.org/project/aioextensions)
  [![Status](
  https://img.shields.io/pypi/status/aioextensions?label=Status&style=flat-square)](
  https://pypi.org/project/aioextensions)
  [![Coverage](
  https://img.shields.io/badge/Coverage-100%25-success?style=flat-square)](
  https://fluidattacks.github.io/aioextensions/)
  [![License](
  https://img.shields.io/pypi/l/aioextensions?color=success&label=License&style=flat-square)](
  https://github.com/fluidattacks/aioextensions/blob/latest/LICENSE.md)


pkgId: 850159816de7c88e9c5fa6fcacb1f9bbadfd367bad91854b063a173725ee853c
name: python-aiofcm
arch: src
version: 1.4
epoch: 0
release: 1
summary: An efficient Firebase Cloud Messaging Client Library for Python/asyncio
url: https://github.com/Fatal1ty/aiofcm
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiofcm-1.4-1.src.rpm
checksum_type: sha256
description:
  **aiofcm** is a library designed specifically for sending messages such as push-notifications
  to Android devices via Firebase Cloud Messaging platform. aiofcm provides an efficient client
  through asynchronous XMPP protocol for use with Python's ``asyncio``
  framework.
  aiofcm requires Python 3.5 or later.


pkgId: ae6a2430f52d6fb3431c33130c7d78b460546eab38d153fdb3708ee59d326609
name: python-aiofile
arch: src
version: 3.9.0
epoch: 0
release: 1
summary: Asynchronous file operations.
url: http://github.com/mosquito/aiofile
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiofile-3.9.0-1.src.rpm
checksum_type: sha256
description:
  [![Github Actions](https://github.com/mosquito/aiofile/workflows/tox/badge.svg)](https://github.com/mosquito/aiofile/actions?query=branch%3Amaster) [![Latest Version](https://img.shields.io/pypi/v/aiofile.svg)](https://pypi.python.org/pypi/aiofile/) [![Wheel](https://img.shields.io/pypi/wheel/aiofile.svg)](https://pypi.python.org/pypi/aiofile/) [![Python Versions](https://img.shields.io/pypi/pyversions/aiofile.svg)](https://pypi.python.org/pypi/aiofile/) [![License](https://img.shields.io/pypi/l/aiofile.svg)](https://pypi.python.org/pypi/aiofile/) [![Coverage Status](https://coveralls.io/repos/github/mosquito/aiofile/badge.svg?branch=master)](https://coveralls.io/github/mosquito/aiofile?branch=master)

  Real asynchronous file operations with asyncio support.



  Development - Stable



  * Since version 2.0.0 using [caio](https://pypi.org/project/caio), which contains linux `libaio` and two
    thread-based implementations (c-based and pure-python).
  * AIOFile has no internal pointer. You should pass `offset` and
    `chunk_size` for each operation or use helpers (Reader or Writer).
    The simplest way is to use `async_open` for creating object with
    file-like interface.
  * For Linux using implementation based on [libaio](https://pagure.io/libaio).
  * For POSIX (MacOS X and optional Linux) using implementation
    based on [threadpool](https://github.com/mbrossard/threadpool/).
  * Otherwise using pure-python thread-based implementation.
  * Implementation chooses automatically depending on system compatibility.



  * Linux native AIO implementation is not able to open special files.
    Asynchronous operations against special fs like `/proc/` `/sys/` are not
    supported by the kernel. It's not a aiofile's or caio issue.
    In these cases, you might switch to thread-based implementations
    (see [Troubleshooting](#troubleshooting) section).
    However, when used on supported file systems, the linux implementation has a
    smaller overhead and is preferred but it's not a silver bullet.



  All code examples require Python 3.6+.





  Helper mimics python file-like objects, it returns file-like
  objects with similar but async methods.

  Supported methods:

  * `async def read(length = -1)` - reading chunk from file, when length is
    `-1`, will be reading file to the end.
  * `async def write(data)` - writing chunk to file
  * `def seek(offset)` - setting file pointer position
  * `def tell()` - returns current file pointer position
  * `async def readline(size=-1, newline="\n")` - read chunks until
    newline or EOF. Since version 3.7.0 `__aiter__` returns `LineReader`.

    This method is suboptimal for small lines because it doesn't reuse read buffer.
    When you want to read file by lines please avoid using `async_open`
    use `LineReader` instead.
  * `def __aiter__() -> LineReader` - iterator over lines.
  * `def iter_chunked(chunk_size: int = 32768) -> Reader` - iterator over
    chunks.
  * `.file` property contains AIOFile object

  Basic example:

  <!-- name: test_basic -->
  ```python
  import asyncio
  from pathlib import Path
  from tempfile import gettempdir

  from aiofile import async_open

  tmp_filename = Path(gettempdir()) / "hello.txt"

  async def main():
      async with async_open(tmp_filename, 'w+') as afp:
          await afp.write("Hello ")
          await afp.write("world")
          afp.seek(0)

          print(await afp.read())

          await afp.write("Hello from\nasync world")
          print(await afp.readline())
          print(await afp.readline())

  asyncio.run(main())
  ```

  Example without context manager:

  <!-- name: test_basic_without_context_manager -->
  ```python
  import asyncio
  import atexit
  import os
  from tempfile import mktemp

  from aiofile import async_open


  TMP_NAME = mktemp()
  atexit.register(os.unlink, TMP_NAME)


  async def main():
      afp = await async_open(TMP_NAME, "w")
      await afp.write("Hello")
      await afp.close()


  asyncio.run(main())
  assert open(TMP_NAME, "r").read() == "Hello"
  ```

  Concatenate example program (`cat`):

  ```python
  import asyncio
  import sys
  from argparse import ArgumentParser
  from pathlib import Path

  from aiofile import async_open

  parser = ArgumentParser(
      description="Read files line by line using asynchronous io API"
  )
  parser.add_argument("file_name", nargs="+", type=Path)

  async def main(arguments):
      for src in arguments.file_name:
          async with async_open(src, "r") as afp:
              async for line in afp:
                  sys.stdout.write(line)


  asyncio.run(main(parser.parse_args()))
  ```

  Copy file example program (`cp`):

  ```python
  import asyncio
  from argparse import ArgumentParser
  from pathlib import Path

  from aiofile import async_open

  parser = ArgumentParser(
      description="Copying files using asynchronous io API"
  )
  parser.add_argument("source", type=Path)
  parser.add_argument("dest", type=Path)
  parser.add_argument("--chunk-size", type=int, default=65535)


  async def main(arguments):
      async with async_open(arguments.source, "rb") as src, \
                 async_open(arguments.dest, "wb") as dest:
          async for chunk in src.iter_chunked(arguments.chunk_size):
              await dest.write(chunk)


  asyncio.run(main(parser.parse_args()))
  ```

  Example with opening already open file pointer:

  ```python
  import asyncio
  from typing import IO, Any
  from aiofile import async_open


  async def main(fp: IO[Any]):
      async with async_open(fp) as afp:
          await afp.write("Hello from\nasync world")
          print(await afp.readline())


  with open("test.txt", "w+") as fp:
      asyncio.run(main(fp))
  ```

  Linux native aio doesn't support reading and writing special files
  (e.g. procfs/sysfs/unix pipes/etc.), so you can perform operations with
  these files using compatible context objects.

  ```python
  import asyncio
  from aiofile import async_open
  from caio import thread_aio_asyncio
  from contextlib import AsyncExitStack


  async def main():
      async with AsyncExitStack() as stack:

          
          ctx = await stack.enter_async_context(
              thread_aio_asyncio.AsyncioContext()
          )

          
          src = await stack.enter_async_context(
              async_open("/proc/cpuinfo", "r", context=ctx)
          )

          
          dest = await stack.enter_async_context(
              async_open("/tmp/cpuinfo", "w")
          )

          
          async for line in src:
              await dest.write(line)


  asyncio.run(main())
  ```



  The `AIOFile` class is a low-level interface for asynchronous file operations, and the read and write methods accept
  an `offset=0` in bytes at which the operation will be performed.

  This allows you to do many independent IO operations on a once open file without moving the virtual carriage.

  For example, you may make 10 concurrent HTTP requests by specifying the `Range` header, and asynchronously write
  one opened file, while the offsets must either be calculated manually, or use 10 instances of `Writer` with
  specified initial offsets.

  In order to provide sequential reading and writing, there is `Writer`, `Reader` and `LineReader`. Keep in mind
  `async_open` is not the same as AIOFile, it provides a similar interface for file operations, it simulates methods
  like read or write as it is implemented in the built-in open.

  ```python
  import asyncio
  from aiofile import AIOFile


  async def main():
      async with AIOFile("hello.txt", 'w+') as afp:
          payload = "Hello world\n"

          await asyncio.gather(
              *[afp.write(payload, offset=i * len(payload)) for i in range(10)]
          )

          await afp.fsync()

          assert await afp.read(len(payload) * 10) == payload * 10

  asyncio.run(main())
  ```

  The Low-level API in fact is just little bit sugared `caio` API.

  ```python
  import asyncio
  from aiofile import AIOFile


  async def main():
      async with AIOFile("/tmp/hello.txt", 'w+') as afp:
          await afp.write("Hello ")
          await afp.write("world", offset=7)
          await afp.fsync()

          print(await afp.read())


  asyncio.run(main())
  ```



  When you want to read or write file linearly following example
  might be helpful.

  ```python
  import asyncio
  from aiofile import AIOFile, Reader, Writer


  async def main():
      async with AIOFile("/tmp/hello.txt", 'w+') as afp:
          writer = Writer(afp)
          reader = Reader(afp, chunk_size=8)

          await writer("Hello")
          await writer(" ")
          await writer("World")
          await afp.fsync()

          async for chunk in reader:
              print(chunk)


  asyncio.run(main())
  ```



  LineReader is a helper that is very effective when you want to read a file
  linearly and line by line.

  It contains a buffer and will read the fragments of the file chunk by
  chunk into the buffer, where it will try to find lines.

  The default chunk size is 4KB.

  ```python
  import asyncio
  from aiofile import AIOFile, LineReader, Writer


  async def main():
      async with AIOFile("/tmp/hello.txt", 'w+') as afp:
          writer = Writer(afp)

          await writer("Hello")
          await writer(" ")
          await writer("World")
          await writer("\n")
          await writer("\n")
          await writer("From async world")
          await afp.fsync()

          async for line in LineReader(afp):
              print(line)


  asyncio.run(main())
  ```

  When you want to read file by lines please avoid to use `async_open`
  use `LineReader` instead.



  Useful examples with `aiofile`



  ```python
  import asyncio
  import io
  from csv import DictReader

  from aiofile import AIOFile, LineReader


  class AsyncDictReader:
      def __init__(self, afp, **kwargs):
          self.buffer = io.BytesIO()
          self.file_reader = LineReader(
              afp, line_sep=kwargs.pop('line_sep', '\n'),
              chunk_size=kwargs.pop('chunk_size', 4096),
              offset=kwargs.pop('offset', 0),
          )
          self.reader = DictReader(
              io.TextIOWrapper(
                  self.buffer,
                  encoding=kwargs.pop('encoding', 'utf-8'),
                  errors=kwargs.pop('errors', 'replace'),
              ), **kwargs,
          )
          self.line_num = 0

      def __aiter__(self):
          return self

      async def __anext__(self):
          if self.line_num == 0:
              header = await self.file_reader.readline()
              self.buffer.write(header)

          line = await self.file_reader.readline()

          if not line:
              raise StopAsyncIteration

          self.buffer.write(line)
          self.buffer.seek(0)

          try:
              result = next(self.reader)
          except StopIteration as e:
              raise StopAsyncIteration from e

          self.buffer.seek(0)
          self.buffer.truncate(0)
          self.line_num = self.reader.line_num

          return result


  async def main():
      async with AIOFile('sample.csv', 'rb') as afp:
          async for item in AsyncDictReader(afp):
              print(item)


  asyncio.run(main())
  ```



  The caio `linux` implementation works normal for modern linux kernel versions
  and file systems. So you may have problems specific for your environment.
  It's not a bug and might be resolved some ways:

  1. Upgrade the kernel
  2. Use compatible file systems
  3. Use threads based or pure python implementation.

  The caio since version 0.7.0 contains some ways to do this.

  1. In runtime use the environment variable `CAIO_IMPL` with
  possible values:

      * `linux` - use native linux kernels aio mechanism
      * `thread` - use thread based implementation written in C
      * `python` - use pure python implementation

  2. File `default_implementation` located near `__init__.py` in caio
  installation path. It's useful for distros package maintainers. This file
  might contains comments (lines starts with `#` symbol) and the first line
  should be one of `linux` `thread` or `python`.

  3. You might manually manage contexts:

  ```python
  import asyncio

  from aiofile import async_open
  from caio import linux_aio_asyncio, thread_aio_asyncio


  async def main():
      linux_ctx = linux_aio_asyncio.AsyncioContext()
      threads_ctx = thread_aio_asyncio.AsyncioContext()

      async with async_open("/tmp/test.txt", "w", context=linux_ctx) as afp:
          await afp.write("Hello")

      async with async_open("/tmp/test.txt", "r", context=threads_ctx) as afp:
          print(await afp.read())


  asyncio.run(main())
  ```


pkgId: 01a74466165a96e552cbcf6592474424b0628ea8288e47c12f7c78ddfba93d83
name: python-aiofiles
arch: src
version: 24.1.0
epoch: 0
release: 1
summary: File support for asyncio.
url: https://pypi.org/project/aiofiles/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiofiles-24.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/aiofiles.svg)](https://pypi.python.org/pypi/aiofiles)
  [![Build](https://github.com/Tinche/aiofiles/workflows/CI/badge.svg)](https://github.com/Tinche/aiofiles/actions)
  [![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/Tinche/882f02e3df32136c847ba90d2688f06e/raw/covbadge.json)](https://github.com/Tinche/aiofiles/actions/workflows/main.yml)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/aiofiles.svg)](https://github.com/Tinche/aiofiles)
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  **aiofiles** is an Apache2 licensed library, written in Python, for handling local
  disk files in asyncio applications.

  Ordinary local file IO is blocking, and cannot easily and portably be made
  asynchronous. This means doing file IO may interfere with asyncio applications,
  which shouldn't block the executing thread. aiofiles helps with this by
  introducing asynchronous versions of files that support delegating operations to
  a separate thread pool.

  ```python
  async with aiofiles.open('filename', mode='r') as f:
      contents = await f.read()
  print(contents)
  'My file contents'
  ```

  Asynchronous iteration is also supported.

  ```python
  async with aiofiles.open('filename') as f:
      async for line in f:
          ...
  ```

  Asynchronous interface to tempfile module.

  ```python
  async with aiofiles.tempfile.TemporaryFile('wb') as f:
      await f.write(b'Hello, World!')
  ```



  - a file API very similar to Python's standard, blocking API
  - support for buffered and unbuffered binary files, and buffered text files
  - support for `async`/`await` ([PEP 492](https://peps.python.org/pep-0492/)) constructs
  - async interface to tempfile module



  To install aiofiles, simply:

  ```bash
  $ pip install aiofiles
  ```



  Files are opened using the `aiofiles.open()` coroutine, which in addition to
  mirroring the builtin `open` accepts optional `loop` and `executor`
  arguments. If `loop` is absent, the default loop will be used, as per the
  set asyncio policy. If `executor` is not specified, the default event loop
  executor will be used.

  In case of success, an asynchronous file object is returned with an
  API identical to an ordinary file, except the following methods are coroutines
  and delegate to an executor:

  - `close`
  - `flush`
  - `isatty`
  - `read`
  - `readall`
  - `read1`
  - `readinto`
  - `readline`
  - `readlines`
  - `seek`
  - `seekable`
  - `tell`
  - `truncate`
  - `writable`
  - `write`
  - `writelines`

  In case of failure, one of the usual exceptions will be raised.

  `aiofiles.stdin`, `aiofiles.stdout`, `aiofiles.stderr`,
  `aiofiles.stdin_bytes`, `aiofiles.stdout_bytes`, and
  `aiofiles.stderr_bytes` provide async access to `sys.stdin`,
  `sys.stdout`, `sys.stderr`, and their corresponding `.buffer` properties.

  The `aiofiles.os` module contains executor-enabled coroutine versions of
  several useful `os` functions that deal with files:

  - `stat`
  - `statvfs`
  - `sendfile`
  - `rename`
  - `renames`
  - `replace`
  - `remove`
  - `unlink`
  - `mkdir`
  - `makedirs`
  - `rmdir`
  - `removedirs`
  - `link`
  - `symlink`
  - `readlink`
  - `listdir`
  - `scandir`
  - `access`
  - `getcwd`
  - `path.abspath`
  - `path.exists`
  - `path.isfile`
  - `path.isdir`
  - `path.islink`
  - `path.ismount`
  - `path.getsize`
  - `path.getatime`
  - `path.getctime`
  - `path.samefile`
  - `path.sameopenfile`



  **aiofiles.tempfile** implements the following interfaces:

  - TemporaryFile
  - NamedTemporaryFile
  - SpooledTemporaryFile
  - TemporaryDirectory

  Results return wrapped with a context manager allowing use with async with and async for.

  ```python
  async with aiofiles.tempfile.NamedTemporaryFile('wb+') as f:
      await f.write(b'Line1\n Line2')
      await f.seek(0)
      async for line in f:
          print(line)

  async with aiofiles.tempfile.TemporaryDirectory() as d:
      filename = os.path.join(d, "file.ext")
  ```



  Real file IO can be mocked by patching `aiofiles.threadpool.sync_open`
  as desired. The return type also needs to be registered with the
  `aiofiles.threadpool.wrap` dispatcher:

  ```python
  aiofiles.threadpool.wrap.register(mock.MagicMock)(
      lambda *args, **kwargs: aiofiles.threadpool.AsyncBufferedIOBase(*args, **kwargs)
  )

  async def test_stuff():
      write_data = 'data'
      read_file_chunks = [
          b'file chunks 1',
          b'file chunks 2',
          b'file chunks 3',
          b'',
      ]
      file_chunks_iter = iter(read_file_chunks)

      mock_file_stream = mock.MagicMock(
          read=lambda *args, **kwargs: next(file_chunks_iter)
      )

      with mock.patch('aiofiles.threadpool.sync_open', return_value=mock_file_stream) as mock_open:
          async with aiofiles.open('filename', 'w') as f:
              await f.write(write_data)
              assert f.read() == b'file chunks 1'

          mock_file_stream.write.assert_called_once_with(write_data)
  ```





  - Import `os.link` conditionally to fix importing on android.
    [#175](https://github.com/Tinche/aiofiles/issues/175)
  - Remove spurious items from `aiofiles.os.__all__` when running on Windows.
  - Switch to more modern async idioms: Remove types.coroutine and make AiofilesContextManager an awaitable instead a coroutine.
  - Add `aiofiles.os.path.abspath` and `aiofiles.os.getcwd`.
    [#174](https://github.com/Tinche/aiofiles/issues/181)
  - _aiofiles_ is now tested on Python 3.13 too.
    [#184](https://github.com/Tinche/aiofiles/pull/184)
  - Dropped Python 3.7 support. If you require it, use version 23.2.1.



  - Import `os.statvfs` conditionally to fix importing on non-UNIX systems.
    [#171](https://github.com/Tinche/aiofiles/issues/171) [#172](https://github.com/Tinche/aiofiles/pull/172)
  - aiofiles is now also tested on Windows.



  - aiofiles is now tested on Python 3.12 too.
    [#166](https://github.com/Tinche/aiofiles/issues/166) [#168](https://github.com/Tinche/aiofiles/pull/168)
  - On Python 3.12, `aiofiles.tempfile.NamedTemporaryFile` now accepts a `delete_on_close` argument, just like the stdlib version.
  - On Python 3.12, `aiofiles.tempfile.NamedTemporaryFile` no longer exposes a `delete` attribute, just like the stdlib version.
  - Added `aiofiles.os.statvfs` and `aiofiles.os.path.ismount`.
    [#162](https://github.com/Tinche/aiofiles/pull/162)
  - Use [PDM](https://pdm.fming.dev/latest/) instead of Poetry.
    [#169](https://github.com/Tinche/aiofiles/pull/169)



  - Added `aiofiles.os.access`.
    [#146](https://github.com/Tinche/aiofiles/pull/146)
  - Removed `aiofiles.tempfile.temptypes.AsyncSpooledTemporaryFile.softspace`.
    [#151](https://github.com/Tinche/aiofiles/pull/151)
  - Added `aiofiles.stdin`, `aiofiles.stdin_bytes`, and other stdio streams.
    [#154](https://github.com/Tinche/aiofiles/pull/154)
  - Transition to `asyncio.get_running_loop` (vs `asyncio.get_event_loop`) internally.



  - Added `aiofiles.os.path.islink`.
    [#126](https://github.com/Tinche/aiofiles/pull/126)
  - Added `aiofiles.os.readlink`.
    [#125](https://github.com/Tinche/aiofiles/pull/125)
  - Added `aiofiles.os.symlink`.
    [#124](https://github.com/Tinche/aiofiles/pull/124)
  - Added `aiofiles.os.unlink`.
    [#123](https://github.com/Tinche/aiofiles/pull/123)
  - Added `aiofiles.os.link`.
    [#121](https://github.com/Tinche/aiofiles/pull/121)
  - Added `aiofiles.os.renames`.
    [#120](https://github.com/Tinche/aiofiles/pull/120)
  - Added `aiofiles.os.{listdir, scandir}`.
    [#143](https://github.com/Tinche/aiofiles/pull/143)
  - Switched to CalVer.
  - Dropped Python 3.6 support. If you require it, use version 0.8.0.
  - aiofiles is now tested on Python 3.11.



  - aiofiles is now tested on Python 3.10.
  - Added `aiofiles.os.replace`.
    [#107](https://github.com/Tinche/aiofiles/pull/107)
  - Added `aiofiles.os.{makedirs, removedirs}`.
  - Added `aiofiles.os.path.{exists, isfile, isdir, getsize, getatime, getctime, samefile, sameopenfile}`.
    [#63](https://github.com/Tinche/aiofiles/pull/63)
  - Added `suffix`, `prefix`, `dir` args to `aiofiles.tempfile.TemporaryDirectory`.
    [#116](https://github.com/Tinche/aiofiles/pull/116)



  - Added the `aiofiles.tempfile` module for async temporary files.
    [#56](https://github.com/Tinche/aiofiles/pull/56)
  - Switched to Poetry and GitHub actions.
  - Dropped 3.5 support.



  - `aiofiles` is now tested on ppc64le.
  - Added `name` and `mode` properties to async file objects.
    [#82](https://github.com/Tinche/aiofiles/pull/82)
  - Fixed a DeprecationWarning internally.
    [#75](https://github.com/Tinche/aiofiles/pull/75)
  - Python 3.9 support and tests.



  - Python 3.8 support. Code base modernization (using `async/await` instead of `asyncio.coroutine`/`yield from`).
  - Added `aiofiles.os.remove`, `aiofiles.os.rename`, `aiofiles.os.mkdir`, `aiofiles.os.rmdir`.
    [#62](https://github.com/Tinche/aiofiles/pull/62)



  - Python 3.7 support.
  - Removed Python 3.3/3.4 support. If you use these versions, stick to aiofiles 0.3.x.



  - The LICENSE is now included in the sdist.
    [#31](https://github.com/Tinche/aiofiles/pull/31)



  - Introduced a changelog.
  - `aiofiles.os.sendfile` will now work if the standard `os` module contains a `sendfile` function.



  Contributions are very welcome. Tests can be run with `tox`, please ensure
  the coverage at least stays the same before you submit a pull request.


pkgId: 98271369eae9ffb65ccfc61d20ae7ee42627684e08e4a496d7b227537400ddaa
name: python-aioflask
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Flask running on asyncio.
url: https://github.com/miguelgrinberg/aioflask
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioflask-0.4.0-1.src.rpm
checksum_type: sha256
description:
  ![Build status](https://github.com/miguelgrinberg/aioflask/workflows/build/badge.svg) [![codecov](https://codecov.io/gh/miguelgrinberg/aioflask/branch/main/graph/badge.svg?token=CDMKF3L0ID)](https://codecov.io/gh/miguelgrinberg/aioflask)

  Flask 2.x running on asyncio!

  Is there a purpose for this, now that Flask 2.0 is out with support for async
  views? Yes! Flask's own support for async handlers is very limited, as the
  application still runs inside a WSGI web server, which severely limits
  scalability. With aioflask you get a true ASGI application, running in a 100%
  async environment.

  WARNING: This is an experiment at this point. Not at all production ready!



  To use async view functions and other handlers, use the `aioflask` package
  instead of `flask`.

  The `aioflask.Flask` class is a subclass of `flask.Flask` that changes a few
  minor things to help the application run properly under the asyncio loop. In
  particular, it overrides the following aspects of the application instance:

  - The `route`, `before_request`, `before_first_request`, `after_request`,
    `teardown_request`, `teardown_appcontext`, `errorhandler` and `cli.command`
    decorators accept coroutines as well as regular functions. The handlers all
    run inside an asyncio loop, so when using regular functions, care must be
    taken to not block.
  - The WSGI callable entry point is replaced with an ASGI equivalent.
  - The `run()` method uses uvicorn as web server.

  There are also changes outside of the `Flask` class:

  - The `flask aiorun` command starts an ASGI application using the uvicorn web
    server.
  - The `render_template()` and `render_template_string()` functions are
    asynchronous and must be awaited.
  - The context managers for the Flask application and request contexts are
    async.
  - The test client and test CLI runner use coroutines.



  ```python
  import asyncio
  from aioflask import Flask, render_template

  app = Flask(__name__)

  @app.route('/')
  async def index():
      await asyncio.sleep(1)
      return await render_template('index.html')
  ```


pkgId: 01c911c281d7239e69b5b9806f3923ee387230d144259dbed3a2fbfc62d70829
name: python-aioflo
arch: src
version: 2021.11.0
epoch: 0
release: 1
summary: A Python3, async-friendly library for Flo by Moen Smart Water Detectors
url: https://github.com/bachya/aioflo
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioflo-2021.11.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/bachya/aioflo/workflows/CI/badge.svg)](https://github.com/bachya/aioflo/actions)
  [![PyPi](https://img.shields.io/pypi/v/aioflo.svg)](https://pypi.python.org/pypi/aioflo)
  [![Version](https://img.shields.io/pypi/pyversions/aioflo.svg)](https://pypi.python.org/pypi/aioflo)
  [![License](https://img.shields.io/pypi/l/aioflo.svg)](https://github.com/bachya/aioflo/blob/master/LICENSE)
  [![Code Coverage](https://codecov.io/gh/bachya/aioflo/branch/master/graph/badge.svg)](https://codecov.io/gh/bachya/aioflo)
  [![Maintainability](https://api.codeclimate.com/v1/badges/1b6949e0c97708925315/maintainability)](https://codeclimate.com/github/bachya/aioflo/maintainability)
  [![Say Thanks](https://img.shields.io/badge/SayThanks-!-1EAEDB.svg)](https://saythanks.io/to/bachya)

  `aioflo` is a Python 3, `asyncio`-friendly library for interacting with
  [Flo by Moen Smart Water Detectors](https://www.moen.com/flo).



  `aioflo` is currently supported on:

  * Python 3.6
  * Python 3.7
  * Python 3.8
  * Python 3.9
  * Python 3.10



  ```python
  pip install aioflo
  ```



  ```python
  import asyncio

  from aiohttp import ClientSession

  from aioflo import async_get_api


  async def main() -> None:
      """Run!"""
      api = await async_get_api("<EMAIL>", "<PASSWORD>")

      
      user_info = await api.user.get_info()
      a_location_id = user_info["locations"][0]["id"]

      
      location_info = await api.location.get_info(a_location_id)

      
      first_device_id = location_info["devices"][0]["id"]
      device_info = await api.device.get_info(first_device_id)

      
      health_test_response = await api.device.run_health_test(first_device_id)

      
      close_valve_response = await api.device.close_valve(first_device_id)

      
      open_valve_response = await api.device.open_valve(first_device_id)

      
      consumption_info = await api.water.get_consumption_info(
          a_location_id,
          datetime(2020, 1, 16, 0, 0),
          datetime(2020, 1, 16, 23, 59, 59, 999000),
      )

      
      metrics = await api.water.get_metrics(
          "<DEVICE_MAC_ADDRESS>",
          datetime(2020, 1, 16, 0, 0),
          datetime(2020, 1, 16, 23, 59, 59, 999000),
      )

      
      await set_mode_away(a_location_id)

      
      await set_mode_home(a_location_id)

      
      await set_mode_sleep(a_location_id, 120, "away")


  asyncio.run(main())
  ```

  By default, the library creates a new connection to Flo with each coroutine. If you are
  calling a large number of coroutines (or merely want to squeeze out every second of
  runtime savings possible), an
  [`aiohttp`](https://github.com/aio-libs/aiohttp) `ClientSession` can be used for connection
  pooling:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from aioflo import async_get_api


  async def main() -> None:
      """Create the aiohttp session and run the example."""
      async with ClientSession() as websession:
          api = await async_get_api("<EMAIL>", "<PASSWORD>", session=session)

          
          ping_response = await api.presence.ping()

          
          user_info = await api.user.get_info()
          a_location_id = user_info["locations"][0]["id"]

          
          location_info = await api.location.get_info(a_location_id)

          
          first_device_id = location_info["devices"][0]["id"]
          device_info = await api.device.get_info(first_device_id)

          
          health_test_response = await api.device.run_health_test(first_device_id)

          
          close_valve_response = await api.device.close_valve(first_device_id)

          
          open_valve_response = await api.device.open_valve(first_device_id)

          
          consumption_info = await api.water.get_consumption_info(
              a_location_id,
              datetime(2020, 1, 16, 0, 0),
              datetime(2020, 1, 16, 23, 59, 59, 999000),
          )

          
          metrics = await api.water.get_metrics(
              "<DEVICE_MAC_ADDRESS>",
              datetime(2020, 1, 16, 0, 0),
              datetime(2020, 1, 16, 23, 59, 59, 999000),
          )

          
          await set_mode_away(a_location_id)

          
          await set_mode_home(a_location_id)

          
          await set_mode_sleep(a_location_id, 120, "away")


  asyncio.run(main())
  ```



  1. [Check for open features/bugs](https://github.com/bachya/aioflo/issues)
    or [initiate a discussion on one](https://github.com/bachya/aioflo/issues/new).
  2. [Fork the repository](https://github.com/bachya/aioflo/fork).
  3. (_optional, but highly recommended_) Create a virtual environment: `python3 -m venv .venv`
  4. (_optional, but highly recommended_) Enter the virtual environment: `source ./.venv/bin/activate`
  5. Install the dev environment: `script/setup`
  6. Code your new feature or bug fix.
  7. Write tests that cover your new functionality.
  8. Run tests and ensure 100% code coverage: `script/test`
  9. Update `README.md` with any new documentation.
  10. Add yourself to `AUTHORS.md`.
  11. Submit a pull request!


pkgId: 3a9903a7cfc83fb3484edec9b779556e355680d081054edf09431fa899024418
name: python-aiofluent
arch: src
version: 1.2.9
epoch: 0
release: 1
summary: A Python logging handler for Fluentd event collector
url: https://github.com/guillotinaweb/aiofluent
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiofluent-1.2.9-1.src.rpm
checksum_type: sha256
description:
  WARNING: This is a fork of the https://github.com/fluent/fluent-logger-python
  project to work with asyncio.
  Many web/mobile applications generate huge amount of event logs (c,f.
  login, logout, purchase, follow, etc). To analyze these event logs could
  be really valuable for improving the service. However, the challenge is
  collecting these logs easily and reliably.
  `Fluentd <https://github.com/fluent/fluentd>`__ solves that problem by
  having: easy installation, small footprint, plugins, reliable buffering,
  log forwarding, etc.
  **aiofluent** is a Python library, to record the events from
  Python application.


pkgId: 73311c38c2fa451513f8c271f34e1330459a885f883aad0a9da6d95afa6e56ad
name: python-aioflureedb
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: Asynchonous library for usage of the FlureeDB API
url: https://github.com/pibara/aioflureedb
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioflureedb-0.8.3-1.src.rpm
checksum_type: sha256
description:
  An asynchonous client library for communicating with a FlureeDB server, making signed transactions and queries.


pkgId: 50b91e7f22b0ac51b2ea8992803a4def47402bcc9da5ddb900068dfbe704f5bd
name: python-aiofreepybox
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Provides asynchronous authentication and access to Freebox servers
url: https://github.com/stilllman/aiofreepybox/tree/aiofreepybox
rpm_license: GNU General Public License (GPL)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiofreepybox-0.0.8-1.src.rpm
checksum_type: sha256
description:
  Easily manage your freebox in Python using the Freebox OS API.
  Check your calls, manage your contacts, configure your dhcp, disable your wifi, monitor your LAN activity and many others, on LAN or remotely.
  aiofreepybox is a python library implementing the freebox OS API. It handles the authentication process and provides a raw access to the freebox API in an asynchronous manner.
  This project is based on fstercq/freepybox, which provides the same features as aiofreepybox in a synchronous manner.


pkgId: 0cf18db8ad9b6101f5ca9090c1a37bafdeb852efc4b5fc07a3744deba079566c
name: python-aiogithubapi
arch: src
version: 24.6.0
epoch: 0
release: 1
summary: Asynchronous Python client for the GitHub API
url: https://github.com/ludeeus/aiogithubapi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogithubapi-24.6.0-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/ludeeus/aiogithubapi/branch/main/graph/badge.svg)](https://codecov.io/gh/ludeeus/aiogithubapi)
  ![python version](https://img.shields.io/badge/Python-3.8=><=3.12-blue.svg)
  [![PyPI](https://img.shields.io/pypi/v/aiogithubapi)](https://pypi.org/project/aiogithubapi)
  ![Actions](https://github.com/ludeeus/aiogithubapi/workflows/Actions/badge.svg?branch=main)

  _Asynchronous Python client for the GitHub API_

  This is not a full client for the API (Have you seen it, it's huge), and will probably never be.
  Things are added when needed or requested.

  If something you need is missing please raise [a feature request to have it added](https://github.com/ludeeus/aiogithubapi/issues/new?assignees=&labels=enhancement&template=feature_request.md) or [create a PR 🎉](#contribute).

  For examples on how to use it see the [tests directory](./tests).



  ```bash
  python3 -m pip install aiogithubapi
  ```



  **Note: This project is currently in a transition phase.**

  In august 2021 a new API interface was introduced (in [#42](https://github.com/ludeeus/aiogithubapi/pull/42)). With that addition, all parts of the old interface is now considered deprecated.
  Which includes:

  - The [`aiogithubapi.common`](./aiogithubapi/common) module
  - The [`aiogithubapi.legacy`](./aiogithubapi/legacy) module
  - The [`aiogithubapi.objects`](./aiogithubapi/objects) module
  - All classes starting with `AIOGitHub`
  - The `async_call_api` function in the [`aiogithubapi/helpers.py`](./aiogithubapi/helpers.py) file
  - The `sigstore_verify_release_asset` function in the [`aiogithubapi/helpers.py`](./aiogithubapi/helpers.py) file
  - The `GitHubDevice` class in `aiogithubapi`, replaced with `GitHubDeviceAPI`
  - The `GitHub` class in `aiogithubapi`, replaced with `GitHubAPI`

  Later this year (2024), warning logs will start to be emitted for deprecated code.

  Early next year (2025), the old code will be removed.



  **All** contributions are welcome!

  1. Fork the repository
  2. Clone the repository locally and open the devcontainer or use GitHub codespaces
  3. Do your changes
  4. Lint the files with `make lint`
  5. Ensure all tests passes with `make test`
  6. Ensure 100% coverage with `make coverage`
  7. Commit your work, and push it to GitHub
  8. Create a PR against the `main` branch


pkgId: 5c8c3a7c6b41d9b3c676b300b141ab78c72634abefe737d03974e355f7ae3d59
name: python-aiogmaps
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Asyncio client library for Google Maps API Web Services
url: https://github.com/hzlmn/aiogmaps
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogmaps-0.0.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/hzlmn/aiogmaps.svg?branch=master)](https://travis-ci.org/hzlmn/aiogmaps)

  Asyncio client library for Google Maps API Web Services



  - [googlemaps](https://github.com/googlemaps/google-maps-services-python) >= 3.0




  ```sh
  pip install aiogmaps
  ```





  ```python
  import asyncio

  from aiogmaps import Client

  async def main(loop):
      api_key = 'xxx'
      async with Client(api_key, loop=loop) as client:
          resp = await client.place(place_id='ChIJN1t_tDeuEmsRUsoyG83frY4')
          print(resp)


  if __name__ == '__main__':
      loop = asyncio.get_event_loop()
      loop.run_until_complete(main(loop))

  ```



  ```python
  import asyncio

  from aiogmaps import Client

  async def main(loop):
      client_id = 'xxx'
      client_secret = 'xxx'
      async with Client(client_id=client_id, client_secret=client_secret, loop=loop) as client:
          resp = await client.place(place_id='ChIJN1t_tDeuEmsRUsoyG83frY4')
          print(resp)


  if __name__ == '__main__':
      loop = asyncio.get_event_loop()
      loop.run_until_complete(main(loop))

  ```



  This library works as a wrapper around official googlemaps library.

  For detailed API reference
  - https://developers.google.com/maps/documentation/
  - https://googlemaps.github.io/google-maps-services-python/docs/


pkgId: 4ff6f34f4e8454241f414e417dd9a6ae2111775e19bfd654b0ce805d6ad96d09
name: python-aiogoogle
arch: src
version: 5.13.0
epoch: 0
release: 1
summary: Async Google API client
url: https://github.com/omarryhan/aiogoogle
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogoogle-5.13.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://github.com/omarryhan/aiogoogle/blob/master/logo.png?raw=true" alt="Logo" title="Aiogoogle" height="233" width="482"/>
    <p align="center">
      <a href="https://github.com/omarryhan/aiogoogle/actions?query=workflow%3ACI"><img alt="Build Status" src="https://github.com/omarryhan/aiogoogle/workflows/CI/badge.svg"></a>
      <a href="https://github.com/omarryhan/aiogoogle"><img alt="Software License" src="https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square"></a>
      <a href="https://github.com/python/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg" /></a>
      <a href="https://static.pepy.tech/badge/aiogoogle"><img alt="Downloads" src="https://static.pepy.tech/badge/aiogoogle"></a>
      <a href="https://static.pepy.tech/badge/aiogoogle/month"><img alt="Monthly Downloads" src="https://static.pepy.tech/badge/aiogoogle/month"></a>
    </p>
  </p>



  **Async** Google API client

  Aiogoogle makes it possible to access most of Google's public APIs which include:

  - Google Calendar API
  - Google Drive API
  - Google Contacts API
  - Gmail API
  - Google Maps API
  - Youtube API
  - Translate API
  - Google Sheets API
  - Google Docs API
  - Gogle Analytics API
  - Google Books API
  - Google Fitness API
  - Google Genomics API
  - Google Cloud Storage
  - Kubernetes Engine API
  - And [more](https://developers.google.com/apis-explorer)



  You can find the documentation [here](https://aiogoogle.readthedocs.io/en/latest/#).


pkgId: 7373fdf2900a69778413d330a1e00e51fc3d8c5f04fea83932f264ead8a3fc61
name: python-aiogqlc
arch: src
version: 5.2.0
epoch: 0
release: 1
summary: aiohttp based GraphQL client
url: https://github.com/DoctorJohn/aiogqlc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogqlc-5.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Versions][versions-image]][versions-url]
  [![PyPI][pypi-image]][pypi-url]
  [![Downloads][downloads-image]][downloads-url]
  [![Codecov][codecov-image]][codecov-url]
  [![License][license-image]][license-url]

  [versions-image]: https://img.shields.io/pypi/pyversions/aiogqlc
  [versions-url]: https://github.com/DoctorJohn/aiogqlc/blob/main/pyproject.toml
  [pypi-image]: https://img.shields.io/pypi/v/aiogqlc
  [pypi-url]: https://pypi.org/project/aiogqlc/
  [downloads-image]: https://img.shields.io/pypi/dm/aiogqlc
  [downloads-url]: https://pypi.org/project/aiogqlc/
  [codecov-image]: https://codecov.io/gh/DoctorJohn/aiogqlc/branch/main/graph/badge.svg
  [codecov-url]: https://codecov.io/gh/DoctorJohn/aiogqlc
  [license-image]: https://img.shields.io/pypi/l/aiogqlc
  [license-url]: https://github.com/DoctorJohn/aiogqlc/blob/main/LICENSE

  A Python asynchronous/IO GraphQL client based on [aiohttp][aiohttp-url].

  In addition to standard HTTP POST `queries` and `mutations` this client fully supports
  the [GraphQL multipart form requests spec][multipart-specs-url] for file uploads
  and the [graphql-ws subprotocol][graphql-ws-url] for WebSocket based `subscriptions`.

  **[Read the documentation][docs-url]**



  ```sh
  pip install aiogqlc
  ```



  Check the [documentation][docs-url] for detailed and more advanced usage examples.



  ```python
  import asyncio
  import aiohttp
  from aiogqlc import GraphQLClient

  ENDPOINT = "https://swapi-graphql.netlify.app/.netlify/functions/index"

  document = """
      query {
          allFilms {
              films {
                  title
              }
          }
      }
  """


  async def main():
      async with aiohttp.ClientSession() as session:
          client = GraphQLClient(ENDPOINT, session=session)
          response = await client.execute(document)
          print(await response.json())


  if __name__ == "__main__":
      asyncio.run(main())
  ```



  ```python
  import aiohttp
  from aiogqlc import GraphQLClient

  document = """
      mutation ($userId: ID!) {
          deleteUser (id: $userId) {
              id
          }
      }
  """

  variables = {
      "userId": "42",
  }


  async def main():
      async with aiohttp.ClientSession() as session:
          client = GraphQLClient("https://example.com/graphql/", session=session)
          response = await client.execute(document, variables=variables)
          print(await response.json())
  ```



  ```python
  import aiohttp
  from aiogqlc import GraphQLClient

  document = """
      mutation($file: Upload!) {
          uploadFile(file: $file) {
              size
          }
      }
  """

  variables = {
      "file": open("test.txt", "rb")
  }


  async def foo():
      async with aiohttp.ClientSession() as session:
          client = GraphQLClient("https://example.com/graphql/", session=session)
          response = await client.execute(document, variables=variables)
          print(await response.json())

  ```



  ```python
  import aiohttp
  from aiogqlc import GraphQLClient

  document = """
      subscription($postId: ID!) {
          likeAdded(postId: $postId)
      }
  """

  variables = {
      "postId": "42"
  }


  async def main():
      async with aiohttp.ClientSession() as session:
          client = GraphQLClient("https://example.com/graphql/", session=session)

          async with client.connect() as connection:
              async for payload in connection.subscribe(document, variables=variables):
                  print(payload)
  ```



  [Read the documentation][docs-url] to learn more about queries, mutations, subscriptions, file uploads and even authentication.

  [aiohttp-url]: https://github.com/aio-libs/aiohttp
  [multipart-specs-url]: https://github.com/jaydenseric/graphql-multipart-request-spec
  [graphql-ws-url]: https://github.com/apollographql/subscriptions-transport-ws
  [docs-url]: https://doctorjohn.github.io/aiogqlc/


pkgId: d818ccc4fa38a9c0b1b07cf890f2d780b8244995cda337a54e9eb946bf2495f8
name: python-aiogram
arch: src
version: 3.13.1
epoch: 0
release: 1
summary: Modern and fully asynchronous framework for Telegram Bot API
url: https://aiogram.dev/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogram-3.13.1-1.src.rpm
checksum_type: sha256
description:
  - Asynchronous (`asyncio docs <https://docs.python.org/3/library/asyncio.html>`_, :pep:`492`)
  - Has type hints (:pep:`484`) and can be used with `mypy <http://mypy-lang.org/>`_
  - Supports `PyPy <https://www.pypy.org/>`_
  - Supports `Telegram Bot API 7.10 <https://core.telegram.org/bots/api>`_ and gets fast updates to the latest versions of the Bot API
  - Telegram Bot API integration code was `autogenerated <https://github.com/aiogram/tg-codegen>`_ and can be easily re-generated when API gets updated
  - Updates router (Blueprints)
  - Has Finite State Machine
  - Uses powerful `magic filters <https://docs.aiogram.dev/en/latest/dispatcher/filters/magic_filters.html#magic-filters>`_
  - Middlewares (incoming updates and API calls)
  - Provides `Replies into Webhook <https://core.telegram.org/bots/faq#how-can-i-make-requests-in-response-to-updates>`_
  - Integrated I18n/L10n support with GNU Gettext (or Fluent)
      It is strongly advised that you have prior experience working
      with `asyncio <https://docs.python.org/3/library/asyncio.html>`_
      before beginning to use **aiogram**.
      If you have any questions, you can visit our community chats on Telegram:
      - 🇺🇸 `@aiogram <https://t.me/aiogram>`_
      - 🇺🇦 `@aiogramua <https://t.me/aiogramua>`_
      - 🇺🇿 `@aiogram_uz <https://t.me/aiogram_uz>`_
      - 🇰🇿 `@aiogram_kz <https://t.me/aiogram_kz>`_
      - 🇷🇺 `@aiogram_ru <https://t.me/aiogram_ru>`_
      - 🇮🇷 `@aiogram_fa <https://t.me/aiogram_fa>`_
      - 🇮🇹 `@aiogram_it <https://t.me/aiogram_it>`_
      - 🇧🇷 `@aiogram_br <https://t.me/aiogram_br>`_


pkgId: 94502d6433a6a3c05cc9a2f67373835ca12720a3a5f7418c7492a76005774bde
name: python-aiogram
arch: src
version: 3.15.0
epoch: 0
release: 1
summary: Modern and fully asynchronous framework for Telegram Bot API
url: https://aiogram.dev/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogram-3.15.0-1.src.rpm
checksum_type: sha256
description:
  - Asynchronous (`asyncio docs <https://docs.python.org/3/library/asyncio.html>`_, :pep:`492`)
  - Has type hints (:pep:`484`) and can be used with `mypy <http://mypy-lang.org/>`_
  - Supports `PyPy <https://www.pypy.org/>`_
  - Supports `Telegram Bot API 8.0 <https://core.telegram.org/bots/api>`_ and gets fast updates to the latest versions of the Bot API
  - Telegram Bot API integration code was `autogenerated <https://github.com/aiogram/tg-codegen>`_ and can be easily re-generated when API gets updated
  - Updates router (Blueprints)
  - Has Finite State Machine
  - Uses powerful `magic filters <https://docs.aiogram.dev/en/latest/dispatcher/filters/magic_filters.html#magic-filters>`_
  - Middlewares (incoming updates and API calls)
  - Provides `Replies into Webhook <https://core.telegram.org/bots/faq#how-can-i-make-requests-in-response-to-updates>`_
  - Integrated I18n/L10n support with GNU Gettext (or Fluent)
      It is strongly advised that you have prior experience working
      with `asyncio <https://docs.python.org/3/library/asyncio.html>`_
      before beginning to use **aiogram**.
      If you have any questions, you can visit our community chats on Telegram:
      - 🇺🇸 `@aiogram <https://t.me/aiogram>`_
      - 🇺🇦 `@aiogramua <https://t.me/aiogramua>`_
      - 🇺🇿 `@aiogram_uz <https://t.me/aiogram_uz>`_
      - 🇰🇿 `@aiogram_kz <https://t.me/aiogram_kz>`_
      - 🇷🇺 `@aiogram_ru <https://t.me/aiogram_ru>`_
      - 🇮🇷 `@aiogram_fa <https://t.me/aiogram_fa>`_
      - 🇮🇹 `@aiogram_it <https://t.me/aiogram_it>`_
      - 🇧🇷 `@aiogram_br <https://t.me/aiogram_br>`_


pkgId: a6c8284631ba5dde8a955604b68390545e2a18807b65154c82119c2ebda9b369
name: python-aiogram-cli
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/aiogram-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogram-cli-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Command line interface for developers

  Works only with [aiogram](https://github.com/aiogram/aiogram) 3.0+

  Here is only bootstrap for CLI interface with extensions based on [pkg_resources](https://setuptools.readthedocs.io/en/latest/pkg_resources.html)




  `pip install aiogram-cli` or `pip install aiogram[cli]`



  Just run in terminal `aiogram` and see what you can do with it.



  [![asciicast](https://asciinema.org/a/5tg0CV7ogvuqQz8ZmHP9CBPjl.svg)](https://asciinema.org/a/5tg0CV7ogvuqQz8ZmHP9CBPjl)



  Any **aiogram-cli** extension package should provide an entry point like this:
  ```
  [aiogram_cli.plugins]
  my_extension = my_package.module:my_command
  ```

  Or with poetry like this:
  ```toml
  [tool.poetry.plugins."aiogram_cli.plugins"]
  "builtin-about" = "aiogram_cli.about:command_about"
  "builtin-plugins" = "aiogram_cli.plugins:command_plugins"
  ```


pkgId: 6e1d9fb4e29922be149087eae426f4c9f9170bdad4069f6c4a02646495e20f22
name: python-aiogram-dialog
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Telegram bot UI framework on top of aiogram
url: https://github.com/tishka17/aiogram_dialog
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogram-dialog-2.2.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/aiogram-dialog.svg)](https://badge.fury.io/py/aiogram-dialog)
  [![Doc](https://readthedocs.org/projects/aiogram-dialog/badge/?version=latest&style=flat)](https://aiogram-dialog.readthedocs.io)
  [![downloads](https://img.shields.io/pypi/dm/aiogram_dialog.svg)](https://pypistats.org/packages/aiogram_dialog)
  [![license](https://img.shields.io/github/license/Tishka17/aiogram_dialog.svg)](https://github.com/Tishka17/aiogram_dialog/blob/master/LICENSE)
  [![license](https://img.shields.io/badge/💬-Telegram-blue)](https://t.me/aiogram_dialog)


  * v2.x - actual release, supports aiogram v3.x
  * v1.x - old release, supports aiogram v2.x, critical fix only


  `aiogram-dialog` is a framework for developing interactive messages and menus in your telegram bot like a normal GUI application.

  It is inspired by ideas of Android SDK and other tools.

  Main ideas are:
  * **split data retrieving, rendering and action processing** - you need nothing to do for showing same content after some actions, also you can show same data in multiple ways.
  * **reusable widgets**  - you can create calendar or multiselect at any point of your application without copy-pasting its internal logic
  * **limited scope of context** - any dialog keeps some data until closed, multiple opened dialogs process their data separately

  Designing you bot with `aiogram-dialog` you **think about user**, what he sees and what he does. Then you split this vision into reusable parts and design your bot combining dialogs, widows and widgets. By this moment you can review interface and add your core logic.

  Many components are ready for use, but you can extend and add your own widgets and even core features.

  For more details see [documentation](https://aiogram-dialog.readthedocs.io) and [examples](example)


  * Rich text rendering using `format` function or `Jinja2` template engine.
  * Automatic message updating after user actions
  * Multiple independent dialog stacks with own data storage and transitions
  * Inline keyboard widgets like `SwitchTo`, `Start`, `Cancel` for state switching, `Calendar` for date selection and others.
  * Stateful widgets: `Checkbox`, `Multiselect`, `Counter`, `TextInput`. They record user actions and allow you to retrieve this data later.
  * Multiple buttons layouts including simple grouping (`Group`, `Column`), page scrolling (`ScrollingGroup`), repeating of same buttons for list of data (`ListGroup`).
  * Sending media (like photo or video) with fileid caching and handling switching to/from message with no media.
  * Different rules of transitions between windows/dialogs like keeping only one dialog on top of stack or force sending enw message instead of updating one.
  * Offline HTML-preview for messages and transitions diagram. They can be used to check all states without emulating real use cases or exported for demonstration purposes.




  Example below is suitable for aiogram_dialog v2.x and aiogram v3.x



  Each window consists of:

  * Text widgets. Render text of message.
  * Keyboard widgets. Render inline keyboard
  * Media widget. Renders media if need
  * Message handler. Called when user sends a message when window is shown
  * Data getter functions (`getter=`). They load data from any source which can be used in text/keyboard
  * State. Used when switching between windows

  **Info:** always create `State` inside `StatesGroup`


  ```python
  from aiogram.fsm.state import StatesGroup, State
  from aiogram_dialog.widgets.text import Format, Const
  from aiogram_dialog.widgets.kbd import Button
  from aiogram_dialog import Window


  class MySG(StatesGroup):
      main = State()


  async def get_data(**kwargs):
      return {"name": "world"}


  Window(
      Format("Hello, {name}!"),
      Button(Const("Empty button"), id="nothing"),
      state=MySG.main,
      getter=get_data,
  )
  ```



  Window itself can do nothing, just prepares message. To use it you need dialog:

  ```python
  from aiogram.fsm.state import StatesGroup, State
  from aiogram_dialog import Dialog, Window


  class MySG(StatesGroup):
      first = State()
      second = State()


  dialog = Dialog(
      Window(..., state=MySG.first),
      Window(..., state=MySG.second),
  )
  ```

  > **Info:** All windows in a dialog MUST have states from then same `StatesGroup`

  After creating a dialog you need to register it into the Dispatcher and set it up using the `setup_dialogs` function:

  ```python
  from aiogram import Dispatcher
  from aiogram_dialog import setup_dialogs

  ...
  dp = Dispatcher(storage=storage)  # create as usual
  dp.include_router(dialog)
  setup_dialogs(dp)
  ```

  Then start dialog when you are ready to use it. Dialog is started via `start` method of `DialogManager` instance. You
  should provide corresponding state to switch into (usually it is state of first window in dialog).

  For example in `/start` command handler:

  ```python
  async def user_start(message: Message, dialog_manager: DialogManager):
      await dialog_manager.start(MySG.first, mode=StartMode.RESET_STACK)

  dp.message.register(user_start, CommandStart())
  ```

  > **Info:** Always set `mode=StartMode.RESET_STACK` in your top level start command. Otherwise, dialogs are stacked just as they do
  on your mobile phone, so you can reach stackoverflow error


pkgId: 13e88995b6a8c99e7155f6839d7e75c0ec72b81cc5c0e1222ac5c6875f928329
name: python-aiogram-inline-paginations
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: A simple library for aiogram that allows you to easily do pagination for any Inline keyboards.
url: https://github.com/daniilshamraev/aiogram-inline-paginations
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogram-inline-paginations-0.1.12-1.src.rpm
checksum_type: sha256
description:
  A simple library for aiogram that allows you to easily do pagination for any Inline keyboards.

  Install for pip:

  ```shell
  pip install aiogram-inline-paginations
  ```

  Install for poetry:

  ```shell
  poetry add aiogram-inline-paginations
  ```



  ```python
  from aiogram_inline_paginations.paginator import Paginator
  from aiogram import types

  kb = types.InlineKeyboardMarkup()
  paginator = Paginator(data=kb, size=5)
  ```



  **data**: Any ready-to-use keyboard InlineKeyboardMarkup or any iterable object with InlineKeyboardButton.

  **size**: The number of rows of buttons on one page, excluding the navigation bar.



  A paginator object that, when called, returns a ready-made keyboard with pagination.



  ```python
  from aiogram_inline_paginations.paginator import Paginator
  from aiogram import types

  kb = types.InlineKeyboardMarkup()
  paginator = Paginator(data=kb, size=5)


  @dp.message_handler()
  async def some_func(message: types.Message):
      await message.answer(
          text='Some menu',
          reply_markup=paginator()
      )
  ```



  Data for registrations paginator.



  ```python
  import random

  from aiogram import Bot, Dispatcher, types
  from aiogram.contrib.fsm_storage.memory import MemoryStorage
  from aiogram.dispatcher.filters import CommandStart
  from aiogram.utils.executor import Executor

  from aiogram_inline_paginations.paginator import Paginator

  token = 'your token'

  storage = MemoryStorage()
  bot = Bot(token=token)
  dp = Dispatcher(bot, storage=storage)


  @dp.message_handler(CommandStart(), state='*')
  async def start(message: types.Message):
      await message.answer('Hello text')

      kb = types.InlineKeyboardMarkup()  # some keyboard

      '''To demonstrate, I will add more than 50 buttons to the keyboard and divide them into 5 lines per page'''
      kb.add(
          *[
              types.InlineKeyboardButton(
                  text=str(random.randint(1000000, 10000000)),
                  callback_data='pass'
              ) for i in range(2)
          ]
      )

      kb.add(
          *[
              types.InlineKeyboardButton(
                  text=str(random.randint(1000000, 10000000)),
                  callback_data='pass'
              ) for i in range(3)
          ]
      )

      kb.add(
          types.InlineKeyboardButton(
              text=str(random.randint(1000000, 10000000)),
              callback_data='pass'
          )
      )

      kb.add(
          *[
              types.InlineKeyboardButton(
                  text=str(random.randint(1000000, 10000000)),
                  callback_data='pass'
              ) for i in range(2)
          ]
      )

      kb.add(
          *[
              types.InlineKeyboardButton(
                  text=str(random.randint(1000000, 10000000)),
                  callback_data='pass'
              ) for i in range(50)
          ]
      )

      paginator = Paginator(data=kb, size=5, dp=dp)

      await message.answer(
          text='Some menu',
          reply_markup=paginator()
      )


  if __name__ == '__main__':
      Executor(dp).start_polling()

  ```



  ```python
  import random

  from aiogram import Bot, Dispatcher, types
  from aiogram.contrib.fsm_storage.memory import MemoryStorage
  from aiogram.dispatcher import FSMContext
  from aiogram.dispatcher.filters import CommandStart, Text
  from aiogram.utils.executor import Executor

  from aiogram_inline_paginations.paginator import CheckBoxPaginator

  token = 'your token'

  storage = MemoryStorage()
  bot = Bot(token=token)
  dp = Dispatcher(bot, storage=storage)


  @dp.message_handler(CommandStart(), state='*')
  async def start(message: types.Message):
      await message.answer('Hello text')

      kb = types.InlineKeyboardMarkup()  # some keyboard
      kb.add(
          *[
              types.InlineKeyboardButton(
                  text=str(random.randint(1000000, 10000000)),
                  callback_data=f'pass_{str(random.randint(1000000, 10000000))}'
              ) for i in range(2)
          ]
      )
      kb.add(
          *[
              types.InlineKeyboardButton(
                  text=str(random.randint(1000000, 10000000)),
                  callback_data=f'pass_{str(random.randint(1000000, 10000000))}'
              ) for i in range(3)
          ]
      )
      kb.add(
          types.InlineKeyboardButton(
              text=str(random.randint(1000000, 10000000)),
              callback_data=f'pass_{str(random.randint(1000000, 10000000))}'
          )
      )
      kb.add(
          *[
              types.InlineKeyboardButton(
                  text=str(random.randint(1000000, 10000000)),
                  callback_data=f'pass_{str(random.randint(1000000, 10000000))}'
              ) for i in range(2)
          ]
      )
      kb.add(
          *[
              types.InlineKeyboardButton(
                  text=str(random.randint(1000000, 10000000)),
                  callback_data=f'pass_{str(random.randint(1000000, 10000000))}'
              ) for i in range(50)
          ]
      )
      paginator = CheckBoxPaginator(
          data=kb,
          size=5,
          callback_startswith='page_',
          callback_startswith_button='pass_',
          confirm_text='Approve',
          dp=dp
      )
      await message.answer(
          text='Some menu',
          reply_markup=paginator()
      )


  @dp.callback_query_handler(Text(startswith='Approve', endswith='confirm'))
  async def approve(call: types.CallbackQuery, state: FSMContext):
      data = await state.get_data()
      selected = data.get('page_selected', None)
      await call.answer(
          text='Your selected"\n'.join(selected)
      )


  if __name__ == '__main__':
      Executor(dp).start_polling()
  ```

  confirim callback:

  ```python
  f"{confirm_text}confirm"
  ```

  selected data:

  ```python
  data = await state.get_data()
  selected = data.get(f'{startswith}selected', None)
  ```



  First page:

  ![img_1.png](https://github.com/daniilshamraev/aiogram-inline-paginations/blob/master/img/img_1.png?raw=true)

  Second page:

  ![img_2.png](https://github.com/daniilshamraev/aiogram-inline-paginations/blob/master/img/img_2.png?raw=true)

  Last page:

  ![img_3.png](https://github.com/daniilshamraev/aiogram-inline-paginations/blob/master/img/img_3.png?raw=true)

  *The order of entries is not lost.*


pkgId: 8457e32e86bcf66ea95e93bdfbcee3030ed46581f42425d1b41bbd27d6d35b47
name: python-aiogram-newsletter
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: Newsletter handler for aiogram bots.
url: https://github.com/nessshon/aiogram-newsletter/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogram-newsletter-0.0.12-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/aiogram-newsletter.svg?color=FFE873&labelColor=3776AB)](https://pypi.python.org/pypi/aiogram-newsletter)
  ![Python Versions](https://img.shields.io/badge/Python-3.8%20--%203.12-black?color=FFE873&labelColor=3776AB)
  [![License](https://img.shields.io/github/license/nessshon/aiogram-newsletter)](https://github.com/nessshon/aiogram-newsletter/blob/main/LICENSE)

  ![Downloads](https://pepy.tech/badge/aiogram-newsletter)
  ![Downloads](https://pepy.tech/badge/aiogram-newsletter/month)
  ![Downloads](https://pepy.tech/badge/aiogram-newsletter/week)

  * Bot example: [@aiogramNewsletterBot](https://t.me/aiogramNewsletterBot/).
  * Code example: [source code](https://github.com/nessshon/aiogram-newsletter/tree/main/example)



  ```bach
  pip install aiogram-newsletter
  ```



  * Coming soon...



  * Ready-to-Use User Interface
  * Middleware Functionality
  * Interface Customization
  * Multilingual Support



  This project utilizes the following dependencies to enhance its functionality:

  - [**aiogram:**](https://pypi.org/project/aiogram/) An asynchronous framework for building Telegram bots.
  - [**APScheduler:**](https://pypi.org/project/APScheduler/) In-process task scheduler with Cron-like capabilities.

  We extend our gratitude to the maintainers and contributors of these libraries for their valuable contributions to the
  open-source community.



  We welcome your contributions! If you have ideas for improvement or have identified a bug, please create an issue or
  submit a pull request.



  **TON** - `EQC-3ilVr-W0Uc3pLrGJElwSaFxvhXXfkiQA3EwdVBHNNess`

  **USDT** (TRC-20) - `TJjADKFT2i7jqNJAxkgeRm5o9uarcoLUeR`



  This repository is distributed under
  the [MIT License](https://github.com/nessshon/aiogram-newsletter/blob/main/LICENSE). Feel free to use, modify, and
  distribute the code in accordance with the terms of the license.


pkgId: 5d71cd438cc6119ab990baeacab7f21ee25d8a7e2492c4e5297b05f901c6574d
name: python-aiogram-tests
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: A library for testing your bots on aiogram
url: https://github.com/aiogram-tests/aiogram_tests
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogram-tests-1.0.3-1.src.rpm
checksum_type: sha256
description:
  ***aiogram_tests*** is a testing library for bots written on <a href="https://github.com/aiogram/aiogram">aiogram</a>







  ```python
  from aiogram import Bot, Dispatcher, types
  from aiogram.fsm.context import FSMContext


  bot = Bot('123456789:AABBCCDDEEFFaabbccddeeff-1234567890')
  dp = Dispatcher()


  @dp.message()
  async def echo(message: types.Message, state: FSMContext) -> None:
      await message.answer(message.text)


  if __name__ == '__main__':
      dp.run_polling(bot)


  ```



  ```python
  import pytest

  from bot import echo

  from aiogram_tests import MockedBot
  from aiogram_tests.handler import MessageHandler
  from aiogram_tests.types.dataset import MESSAGE


  @pytest.mark.asyncio
  async def test_echo():
      request = MockedBot(MessageHandler(echo))
      calls = await request.query(message=MESSAGE.as_object(text="Hello, Bot!"))
      answer_message = calls.send_messsage.fetchone()
      assert answer_message.text == "Hello, Bot!"

  ```


pkgId: 205de3370c4aeb72b6221362912645bdcd4b1a640ac67891e8c87ad48b84ad67
name: python-aiogram-tonconnect
arch: src
version: 0.14.2
epoch: 0
release: 1
summary: TON Connect UI for aiogram bots.
url: https://github.com/nessshon/aiogram-tonconnect/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogram-tonconnect-0.14.2-1.src.rpm
checksum_type: sha256
description:
  [![TON](https://img.shields.io/badge/TON-grey?logo=TON&logoColor=40AEF0)](https://ton.org)
  [![PyPI](https://img.shields.io/pypi/v/aiogram-tonconnect.svg?color=FFE873&labelColor=3776AB)](https://pypi.python.org/pypi/aiogram-tonconnect)
  ![Python Versions](https://img.shields.io/badge/Python-3.8%20--%203.12-black?color=FFE873&labelColor=3776AB)
  [![License](https://img.shields.io/github/license/nessshon/aiogram-tonconnect)](https://github.com/nessshon/aiogram-tonconnect/blob/main/LICENSE)


  <img src="https://telegra.ph//file/9e28473c8da8989fdf027.jpg">

  ![Downloads](https://pepy.tech/badge/aiogram-tonconnect)
  ![Downloads](https://pepy.tech/badge/aiogram-tonconnect/month)
  ![Downloads](https://pepy.tech/badge/aiogram-tonconnect/week)

  **Aiogram TON Connect UI** is a middleware library that streamlines the integration
  of [TON Connect](https://github.com/ton-connect) technology into Telegram bots based
  on [aiogram](https://github.com/aiogram/). It offers a pre-built user interface and orchestrates the interaction flow
  for connecting wallets and initiating transactions. The library takes care of all user interactions with TON Connect
  within the bot, encompassing the presentation of QR codes, texts, and keyboards, along with the handling of timeouts and
  user cancellations.

  Check out the [documentation](https://nessshon.github.io/aiogram-tonconnect/).\
  Bot example [@aiogramTONConnectBot](https://t.me/aiogramTONConnectBot/).



  ```bach
  pip install aiogram-tonconnect
  ```



  * Ready-to-Use User Interface
  * Middleware Functionality
  * Interface Customization
  * Multilingual Support
  * QR Code Generation



  |                                                                                                                      |                                                                                                                      |                                                                                                                      |
  |----------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------|
  | [![Image 1](https://telegra.ph//file/555175fd35c05370a64d4.jpg)](https://telegra.ph//file/555175fd35c05370a64d4.jpg) | [![Image 2](https://telegra.ph//file/ef770d825534cf049c1bb.jpg)](https://telegra.ph//file/ef770d825534cf049c1bb.jpg) | [![Image 3](https://telegra.ph//file/502a80771bc07acc6e93b.jpg)](https://telegra.ph//file/502a80771bc07acc6e93b.jpg) |
  | [![Image 4](https://telegra.ph//file/99443226ba404a86586ad.jpg)](https://telegra.ph//file/99443226ba404a86586ad.jpg) | [![Image 5](https://telegra.ph//file/74fba6fca9c273d5f6f30.jpg)](https://telegra.ph//file/74fba6fca9c273d5f6f30.jpg) | [![Image 6](https://telegra.ph//file/656593c298123fea6be60.jpg)](https://telegra.ph//file/656593c298123fea6be60.jpg) |



  This project utilizes the following dependencies to enhance its functionality:

  - [**aiogram:**](https://pypi.org/project/aiogram/) An asynchronous framework for building Telegram bots.
  - [**pytonconnect:**](https://pypi.org/project/pytonconnect/) Python SDK for TON Connect 2.0.
  - [**pytoniq-core:**](https://pypi.org/project/pytoniq-core/) TON Blockchain primitives.
  - [**qrcode-fastapi:**](https://github.com/nessshon/qrcode-fastapi) Generate QR codes with optional image inclusion,
    supports base64-encoded.
  - and more...

  We extend our gratitude to the maintainers and contributors of these libraries for their valuable contributions to the
  open-source community.



  We welcome your contributions! If you have ideas for improvement or have identified a bug, please create an issue or
  submit a pull request.



  Supported by [TON Society](https://github.com/ton-society/grants-and-bounties), Grants and Bounties program.



  **TON** - `EQC-3ilVr-W0Uc3pLrGJElwSaFxvhXXfkiQA3EwdVBHNNess`

  **USDT** (TRC-20) - `TJjADKFT2i7jqNJAxkgeRm5o9uarcoLUeR`



  This repository is distributed under
  the [MIT License](https://github.com/nessshon/aiogram-tonconnect/blob/main/LICENSE). Feel free to use, modify, and
  distribute the code in accordance with the terms of the license.


pkgId: f8c5b1e0a6000f2080c8f25304e5d0d8f1e84622779d7505a51b1503f1d0dbae
name: python-aiogram-tonconnect
arch: src
version: 0.14.3
epoch: 0
release: 1
summary: TON Connect UI for aiogram bots.
url: https://github.com/nessshon/aiogram-tonconnect/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogram-tonconnect-0.14.3-1.src.rpm
checksum_type: sha256
description:
  [![TON](https://img.shields.io/badge/TON-grey?logo=TON&logoColor=40AEF0)](https://ton.org)
  [![PyPI](https://img.shields.io/pypi/v/aiogram-tonconnect.svg?color=FFE873&labelColor=3776AB)](https://pypi.python.org/pypi/aiogram-tonconnect)
  ![Python Versions](https://img.shields.io/badge/Python-3.8%20--%203.12-black?color=FFE873&labelColor=3776AB)
  [![License](https://img.shields.io/github/license/nessshon/aiogram-tonconnect)](https://github.com/nessshon/aiogram-tonconnect/blob/main/LICENSE)


  <img src="https://telegra.ph//file/9e28473c8da8989fdf027.jpg">

  ![Downloads](https://pepy.tech/badge/aiogram-tonconnect)
  ![Downloads](https://pepy.tech/badge/aiogram-tonconnect/month)
  ![Downloads](https://pepy.tech/badge/aiogram-tonconnect/week)

  **Aiogram TON Connect UI** is a middleware library that streamlines the integration
  of [TON Connect](https://github.com/ton-connect) technology into Telegram bots based
  on [aiogram](https://github.com/aiogram/). It offers a pre-built user interface and orchestrates the interaction flow
  for connecting wallets and initiating transactions. The library takes care of all user interactions with TON Connect
  within the bot, encompassing the presentation of QR codes, texts, and keyboards, along with the handling of timeouts and
  user cancellations.

  Check out the [documentation](https://nessshon.github.io/aiogram-tonconnect/).\
  Bot example [@aiogramTONConnectBot](https://t.me/aiogramTONConnectBot/).



  ```bach
  pip install aiogram-tonconnect
  ```



  * Ready-to-Use User Interface
  * Middleware Functionality
  * Interface Customization
  * Multilingual Support
  * QR Code Generation



  |                                                                                                                      |                                                                                                                      |                                                                                                                      |
  |----------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------|
  | [![Image 1](https://telegra.ph//file/555175fd35c05370a64d4.jpg)](https://telegra.ph//file/555175fd35c05370a64d4.jpg) | [![Image 2](https://telegra.ph//file/ef770d825534cf049c1bb.jpg)](https://telegra.ph//file/ef770d825534cf049c1bb.jpg) | [![Image 3](https://telegra.ph//file/502a80771bc07acc6e93b.jpg)](https://telegra.ph//file/502a80771bc07acc6e93b.jpg) |
  | [![Image 4](https://telegra.ph//file/99443226ba404a86586ad.jpg)](https://telegra.ph//file/99443226ba404a86586ad.jpg) | [![Image 5](https://telegra.ph//file/74fba6fca9c273d5f6f30.jpg)](https://telegra.ph//file/74fba6fca9c273d5f6f30.jpg) | [![Image 6](https://telegra.ph//file/656593c298123fea6be60.jpg)](https://telegra.ph//file/656593c298123fea6be60.jpg) |



  This project utilizes the following dependencies to enhance its functionality:

  - [**aiogram:**](https://pypi.org/project/aiogram/) An asynchronous framework for building Telegram bots.
  - [**pytonconnect:**](https://pypi.org/project/pytonconnect/) Python SDK for TON Connect 2.0.
  - [**pytoniq-core:**](https://pypi.org/project/pytoniq-core/) TON Blockchain primitives.
  - [**qrcode-fastapi:**](https://github.com/nessshon/qrcode-fastapi) Generate QR codes with optional image inclusion,
    supports base64-encoded.
  - and more...

  We extend our gratitude to the maintainers and contributors of these libraries for their valuable contributions to the
  open-source community.



  We welcome your contributions! If you have ideas for improvement or have identified a bug, please create an issue or
  submit a pull request.



  Supported by [TON Society](https://github.com/ton-society/grants-and-bounties), Grants and Bounties program.



  **TON** - `EQC-3ilVr-W0Uc3pLrGJElwSaFxvhXXfkiQA3EwdVBHNNess`

  **USDT** (TRC-20) - `TGKmm9H3FApFw8xcgRcZDHSku68vozAjo9`



  This repository is distributed under
  the [MIT License](https://github.com/nessshon/aiogram-tonconnect/blob/main/LICENSE). Feel free to use, modify, and
  distribute the code in accordance with the terms of the license.


pkgId: 7cd4d4c3b20444a1bde1c8ef73385fd49438fffdd3662d50a1c8c36552aee2eb
name: python-aiogram-widgets
arch: src
version: 1.2.7
epoch: 0
release: 1
summary: Create most popular widgets for aiogram 3 in few code lines
url: https://pypi.org/project/aiogram-widgets/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogram-widgets-1.2.7-1.src.rpm
checksum_type: sha256
description:
  Create most popular widgets for aiogram 3x in a few code lines



  [![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)
  [![Github](https://img.shields.io/github/stars/ggindinson?label=GitHub%20Repo&style=social)](https://github.com/ggindinson/aiogram_widgets)
  [![PyPI - Package](https://img.shields.io/pypi/v/aiogram_widgets)](https://pypi.org/project/aiogram-widgets/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/aiogram_widgets)](https://pypistats.org/packages/aiogram-widgets)



  - Fully customizable widgets
  - Stateless
  - Automatic handling
  - Supports aiogram ^3.0.0b1




  - Checkboxes and multiselect

  - Calendar

  - Aiogram 2x support




  `Version 1.2.7:`
  - Fixed a bug that still required `pagination_key` option

  `Version 1.2.6:`
  - Fixed a bug that caused uncompability in python versions 3.10 and lower


  `Version 1.2.5:`
  - Added the ability to adjust buttons passing tuple of sizes (works the similar way as in InlineKeyboardBuilder.adjust) in keyboard pagination


  `Version 1.2.4:`
  - Fixed aiogram dependency bug

  `Version 1.2.3:`
  - Fixed typings at Python 3.9
  - `pagination_key` option now is not required
  - Better types naming

  `Version 1.2.2:`
  - Custom pagination keyboard support
  - Aiogram 3.0.0b8 support
  - README with more examples
  - Live bot example with source code
  - Better types naming




  Pip:

  ```bash
  pip install aiogram_widgets
  ```

  Poetry:

  ```bash
  poetry add aiogram_widgets
  ```



  ![](https://raw.githubusercontent.com/ggindinson/aiogram_widgets/main/demo.gif)










  ```python
  from aiogram_widgets.pagination import KeyboardPaginator

  @router.message(F.text == "/keyboard_pagination")
  async def keyboard_pagination(message: Message):
      buttons = [
          InlineKeyboardButton(text=f"Button {i}", callback_data=f"button_{i}")
          for i in range(1, 1001)
      ]
      paginator = KeyboardPaginator(
          data=buttons,
          per_page=20,
          per_row=2
      )


      await message.answer(text="Keyboard pagination", reply_markup=paginator.as_markup())

  ```

  ```python
  from aiogram_widgets.pagination import KeyboardPaginator

  @router.message(F.text == "/kb_additional_buttons")
  async def kb_additional_buttons(message: Message):
      buttons = [
          InlineKeyboardButton(text=f"Button {i}", callback_data=f"button_{i}")
          for i in range(1, 1001)
      ]
      additional_buttons = [
          [
              InlineKeyboardButton(text="Go back 🔙", callback_data="go_back"),
          ]
      ]

      paginator = KeyboardPaginator(
          data=buttons,
          additional_buttons=additional_buttons,
          per_page=20,
          per_row=2
      )

      await message.answer(
          text="Keyboard pagination with additional buttons",
          reply_markup=paginator.as_markup(),
      )

  ```

  ``` python
  @router.message(F.text == "/kb_custom_pagination")
  async def kb_custom_pagination(message: Message):
      text_data = [f"I am string number {i}" for i in range(1, 1001)]
      pagination_buttons = [
          None, "<-", "->", None
      ]

      paginator = TextPaginator(
          data=text_data,
          pagination_buttons=pagination_buttons,
      )

      current_text_chunk, reply_markup = paginator.current_message_data

      await message.answer(
          text=current_text_chunk,
          reply_markup=reply_markup,
      )

  ```


  ```python
  from aiogram_widgets.pagination import TextPaginator


  @router.message(F.text == "/text_pagination")
  async def text_pagination(message: Message):
      text_data = [
          f"I am string number {i}"
          for i in range(1, 1001)
      ]

      paginator = TextPaginator(
          data=text_data,
      )

      current_text_chunk, reply_markup = paginator.current_message_data

      await message.answer(
          text=current_text_chunk,
          reply_markup=reply_markup,
      )

  ```




  ```python
  @router.message(F.text == "/text_join")
  async def text_custom_join(message: Message):
      text_data = [f"I am string number {i}" for i in range(1, 1001)]

      paginator = TextPaginator(
          data=text_data,
          join_symbol="\n\n",
      )
      current_text_chunk, reply_markup = paginator.current_message_data

      await message.answer(
          text=current_text_chunk,
          reply_markup=reply_markup,
      )

  ```



  I would be very pleased for a star ⭐️


pkgId: d75d57d821a5b5114b5aa02902869e9b17bba99b9f815ddcfea3051ec4f0e7b0
name: python-aiogram3-form
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: A library for creating forms in aiogram3
url: https://pypi.org/project/aiogram3-form/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogram3-form-2.0.4-1.src.rpm
checksum_type: sha256
description:
  A library for creating forms in aiogram3

  ```shell
  pip install aiogram3-form
  ```



  Form is a set of fields that you want your user to fill in. Forms are defined as classses derived from `aiogram3_form.Form` and contain fields with annotated types and `aiogram3_form.FormField` values. You should not inherit your form class from your another form class. (so no deep inheritance).

  When you start your form with `.start()` method, your bot will ask a user input values one by one until the end. Filling in the last field of a form means "submitting" it.

  Forms use default aiogram FSM.



  ```Python
  import asyncio

  from aiogram import Bot, Dispatcher, F, Router
  from aiogram3_form import Form, FormField
  from aiogram.fsm.context import FSMContext

  bot = Bot(token="YOUR_TOKEN")
  dispatcher = Dispatcher()
  router = Router()
  dispatcher.include_router(router)


  class NameForm(Form):
      first_name: str = FormField(enter_message_text="Enter your first name please")
      second_name: str = FormField(
          enter_message_text="Enter your second name please",
          filter=(F.text.len() > 10) & F.text,
      )
      age: int = FormField(enter_message_text="Enter age as integer")


  @NameForm.submit(router=router)
  async def name_form_submit_handler(form: NameForm):
      
      
      
      await form.answer(f"{form.first_name} {form.second_name} of age {form.age}")


  @router.message(F.text == "/form")
  async def form_handler(_, state: FSMContext):
      await NameForm.start(bot, state)  # start your form


  asyncio.run(dispatcher.start_polling(bot))
  ```



  You can use any type of keyboard in your form, but only reply keyboards are actually useful. (cause forms only accept messages as input, so no callback queries)

  ```Python
  FRUITS = ("Orange", "Apple", "Banana")

  fruits_markup = (
      ReplyKeyboardBuilder().add(*(KeyboardButton(text=f) for f in FRUITS)).as_markup()
  )


  class FruitForm(Form):
      fruit: str = FormField(
          enter_message_text="Pick your favorite fruit",
          filter=F.text.in_(FRUITS) & F.text,
          reply_markup=fruits_markup,
      )
  ```



  Default filters are built in for types: `str` (checks for mesasge text and returns it), `int` (tries to convert message text to int), `float`, `datetime.date`, `datetime.datetime`, `aiogram.types.PhotoSize`, `aiogram.types.Document`, `aiogram.types.Message`

  Supported form filter kinds: sync function, async function, aiogram magic filter.

  If your filter is a function (sync or async), it should take `aiogram.types.Message` as the first argument and return `False`, if it does not pass. If a filter passed, it should return the value you want in your form data.

  Magic filters return `None` on failure, so it's a special case that is handled differently.

  If your filter fails and `error_message_text` is provided in `FormField` call, an error message will be sent with the provided text.

  ```Python
  def sync_fruit_form_filter(message: types.Message) -> str:
      if message.text not in FRUITS:
          return False

      return message.text


  async def async_fruit_form_filter(
      message: types.Message,
  ): ...  # some async fruit filtering


  class FruitForm(Form):
      fruit: str = FormField(
          enter_message_text="Pick your favorite fruit",
          filter=sync_fruit_form_filter,  # you can pass an async filter here as well
          reply_markup=fruits_markup,
          error_message_text="Thats an invalid fruit",
      )
  ```



  Enter callbacks enable you to write your own enter functions for form fields

  ```Python
  async def enter_fruit_callback(chat_id: int, user_id: int, data: dict[str, Any]):
      
      print(f"user {user_id} has just entered the fruit callback in chat {chat_id}!")

      return await bot.send_message(
          chat_id, "Hey, pick your favorite fruit please", reply_markup=fruits_markup
      )


  class FruitForm(Form):
      fruit: str = FormField(
          enter_callback=enter_fruit_callback,
          filter=sync_fruit_form_filter,
          error_message_text="Thats an invalid fruit",
      )
  ```


pkgId: 7e2b8b141bdc0efeaadc8e89fa5c979647ac61b5842a4c29438816530a3e7f27
name: python-aiogramarch
arch: src
version: 1.2
epoch: 0
release: 1
summary: Managing aiogram projects
url: https://pypi.org/project/aiogramarch/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogramarch-1.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center">Project manager and generator for Aiogram</p>






  ``` python
  pip install aiogramarch
  ```



  ``` bash
  aiogramarch startproject [projectname]
  ```

  ``` bash
  cd codingbot
  ```

  ``` bash
  aiogramarch startapp [appname]
  ```

  ``` bash
  aiogramarch includeRedis
  ```

  ``` bash
  aiogramarch includeFastapi
  ```

  ``` bash
  aiogramarch includeAdmin
  ```



  ``` bash
  aiogramarch --help
  ```


pkgId: c4922ffdd66794db8eed5ea324cc584fd2913c63399206aef9bdfe686d0402cc
name: python-aiographfix
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: asynchronous Python Telegra.ph API wrapper
url: https://github.com/Yyonging/aiograph.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiographfix-0.2.2-1.src.rpm
checksum_type: sha256
description:
  |shield-pypi| |shield-pypi-status| |shield-travis| |shield-codecov| |shield-license|
  **aiographfix** - asynchronous Python Telegra.ph API wrapper, that fix aiograph


pkgId: 8531835d57aec6fd59ec8092c098b0efc7e2838784e39e63c7af4a317a587485
name: python-aiographql-client
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: An asyncio GraphQL client built on top of aiohttp and graphql-core-next
url: https://github.com/abn/aiographql-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiographql-client-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/aiographql-client.svg)](https://badge.fury.io/py/aiographql-client)
  [![Python Versions](https://img.shields.io/pypi/pyversions/aiographql-client)](https://pypi.org/project/aiographql-client/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Documentation Status](https://readthedocs.org/projects/aiographql-client/badge/?version=latest)](https://aiographql-client.readthedocs.io/en/latest/?badge=latest)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Sonarcloud Status](https://sonarcloud.io/api/project_badges/measure?project=abn_aiographql-client&metric=alert_status)](https://sonarcloud.io/dashboard?id=abn_aiographql-client)
  [![](https://github.com/abn/aiographql-client/workflows/Test%20Suite/badge.svg)](https://github.com/abn/aiographql-client/actions?query=workflow%3A%22Test+Suite%22)

  An asynchronous GraphQL client built on top of aiohttp and graphql-core-next. The client by default introspects schemas and validates all queries prior to dispatching to the server.



  For the most recent project documentation, you can visit https://aiographql-client.readthedocs.io/.


  `pip install aiographql-client`


  Here are some example usages of this client implementation. For more examples, and advanced scenarios,
  see [Usage Examples](https://aiographql-client.readthedocs.io/en/latest/examples.html) section in
  the documentation.


  ```py
  async def get_logged_in_username(token: str) -> GraphQLResponse:
      client = GraphQLClient(
          endpoint="https://api.github.com/graphql",
          headers={"Authorization": f"Bearer {token}"},
      )
      request = GraphQLRequest(
          query="""
              query {
                viewer {
                  login
                }
              }
          """
      )
      return await client.query(request=request)
  ```

  ```console
  >>> import asyncio
  >>> response = asyncio.run(get_logged_in_username("<TOKEN FROM GITHUB GRAPHQL API>"))
  >>> response.data
  {'viewer': {'login': 'username'}}
  ```


  ```py
  async def print_city_updates(client: GraphQLClient, city: str) -> None:
      request = GraphQLRequest(
          query="""
              subscription ($city:String!) {
                city(where: {name: {_eq: $city}}) {
                  description
                  id
                }
              }
          """,
          variables={"city": city},
      )
      
      await client.subscribe(
          request=request, on_data=print, on_error=print, wait=True
      )
  ```

  For custom event specific callback registration, see [Callback Registry Documentation](https://aiographql-client.readthedocs.io/en/latest/examples.html#callback-registry).


  If your query is invalid, thanks to graphql-core-next, we get a detailed exception in the traceback.

  ```
  aiographql.client.exceptions.GraphQLClientValidationException: Query validation failed

  Cannot query field 'ids' on type 'chatbot'. Did you mean 'id'?

  GraphQL request (4:13)
  3:           chatbot {
  4:             ids, bot_names
                 ^
  5:           }

  Cannot query field 'bot_names' on type 'chatbot'. Did you mean 'bot_name' or 'bot_language'?

  GraphQL request (4:18)
  3:           chatbot {
  4:             ids, bot_names
                      ^
  5:           }

  ```


  Support for multi-operation requests and variables is available via the client. For example,
  the following request contains multiple operations. The instance specifies default values to use.

  ```py
  request = GraphQLRequest(
      query="""
      query get_bot_created($id: Int) {
        chatbot(where: {id: {_eq: $id}}) {
          id, created
        }
      }
      query get_bot_name($id: Int) {
        chatbot(where: {id: {_eq: $id}}) {
          id, bot_name
        }
      }
      """,
      variables={"id": 109},
      operation="get_bot_name"
  )
  ```

  The default values can be overridden at the time of making the request if required.

  ```py
  await client.query(request=request, variables={"id": 20}, operation="get_bot_created")
  ```


pkgId: bcdee846644278ff6487216f216a0b7edb5f7155a674b9d57efb7dd0b1f9c7f2
name: python-aiogrobid
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/izihawa/aiogrobid
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiogrobid-0.1.12-1.src.rpm
checksum_type: sha256
description:
  Asynchronous client for Grobid API



  ```python
  import asyncio

  from aiogrobid import GrobidClient

  async def works(doi):
      client = GrobidClient()
      return await client.works(doi)

  response = asyncio.get_event_loop().run_until_complete(works('10.21100/compass.v11i2.812'))
  assert(response == {
    'DOI': '10.21100/compass.v11i2.812',
    'ISSN': ['2044-0081', '2044-0073'],
    'URL': 'http://dx.doi.org/10.21100/compass.v11i2.812',
    'abstract': '<jats:p>Abstract: Educational policy and provision is '
                'ever-changing; but how does pedagogy need to adapt to respond '
                'to transhumanism? This opinion piece discusses transhumanism, '
                'questions what it will mean to be posthuman, and considers the '
                'implications of this on the future of education.</jats:p>',
    'author': [ { 'affiliation': [],
                  'family': 'Gibson',
                  'given': 'Poppy Frances',
                  'sequence': 'first'}],
    'container-title': ['Compass: Journal of Learning and Teaching'],
    'content-domain': {'crossmark-restriction': False, 'domain': []},
    'created': { 'date-parts': [[2018, 12, 17]],
                 'date-time': '2018-12-17T09:42:26Z',
                 'timestamp': 1545039746000},
    'deposited': { 'date-parts': [[2019, 6, 11]],
                   'date-time': '2019-06-11T10:29:57Z',
                   'timestamp': 1560248997000},
    'indexed': { 'date-parts': [[2020, 4, 14]],
                 'date-time': '2020-04-14T14:52:16Z',
                 'timestamp': 1586875936184},
    'is-referenced-by-count': 0,
    'issn-type': [ {'type': 'print', 'value': '2044-0073'},
                   {'type': 'electronic', 'value': '2044-0081'}],
    'issue': '2',
    'issued': {'date-parts': [[2018, 12, 10]]},
    'journal-issue': { 'issue': '2',
                       'published-online': {'date-parts': [[2018, 12, 10]]}},
    'link': [ { 'URL': 'https://journals.gre.ac.uk/index.php/compass/article/viewFile/812/pdf',
                'content-type': 'application/pdf',
                'content-version': 'vor',
                'intended-application': 'text-mining'},
              { 'URL': 'https://journals.gre.ac.uk/index.php/compass/article/viewFile/812/pdf',
                'content-type': 'unspecified',
                'content-version': 'vor',
                'intended-application': 'similarity-checking'}],
    'member': '8854',
    'original-title': [],
    'prefix': '10.21100',
    'published-online': {'date-parts': [[2018, 12, 10]]},
    'publisher': 'Educational Development Unit, University of Greenwich',
    'reference-count': 0,
    'references-count': 0,
    'relation': {},
    'score': 1.0,
    'short-container-title': ['Compass'],
    'short-title': [],
    'source': 'Crossref',
    'subtitle': [],
    'title': [ 'From Humanities to Metahumanities: Transhumanism and the Future '
               'of Education'],
    'type': 'journal-article',
    'volume': '11'})
  ```


pkgId: e1749835524c39908ec6ec6b1c4fcccd8351f18c664610ac81a9f999666593d8
name: python-aioguardian
arch: src
version: 2023.12.0
epoch: 0
release: 1
summary: A Python3 library for Elexa Guardian water valves and sensors
url: https://github.com/bachya/aioguardian
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioguardian-2023.12.0-1.src.rpm
checksum_type: sha256
description:
  [![CI][ci-badge]][ci]
  [![PyPI][pypi-badge]][pypi]
  [![Version][version-badge]][version]
  [![License][license-badge]][license]
  [![Code Coverage][codecov-badge]][codecov]
  [![Maintainability][maintainability-badge]][maintainability]

  <a href="https://www.buymeacoffee.com/bachya1208P" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-orange.png" alt="Buy Me A Coffee" height="41" width="174"></a>

  `aioguardian` is a Python3, `asyncio`-focused library for interacting with
  [the Guardian line of water valves and sensors from Elexa][elexa].

  - [Installation](#installation)
  - [Python Versions](#python-versions)
  - [Documentation](#documentation)
  - [Contributing](#contributing)



  ```bash
  pip install aioguardian
  ```



  `aioguardian` is currently supported on:

  - Python 3.10
  - Python 3.11
  - Python 3.12



  Complete documentation can be found [here][docs].



  Thanks to all of [our contributors][contributors] so far!

  1. [Check for open features/bugs][issues] or [initiate a discussion on one][new-issue].
  2. [Fork the repository][fork].
  3. (_optional, but highly recommended_) Create a virtual environment: `python3 -m venv .venv`
  4. (_optional, but highly recommended_) Enter the virtual environment: `source ./.venv/bin/activate`
  5. Install the dev environment: `script/setup`
  6. Code your new feature or bug fix on a new branch.
  7. Write tests that cover your new functionality.
  8. Run tests and ensure 100% code coverage: `poetry run pytest --cov aioguardian tests`
  9. Update `README.md` with any new documentation.
  10. Submit a pull request!

  [ci-badge]: https://github.com/bachya/aioguardian/workflows/CI/badge.svg
  [ci]: https://github.com/bachya/aioguardian/actions
  [codecov-badge]: https://codecov.io/gh/bachya/aioguardian/branch/dev/graph/badge.svg
  [codecov]: https://codecov.io/gh/bachya/aioguardian
  [contributors]: https://github.com/bachya/aioguardian/graphs/contributors
  [docs]: http://aioguardian.readthedocs.io
  [elexa]: http://getguardian.com
  [fork]: https://github.com/bachya/aioguardian/fork
  [issues]: https://github.com/bachya/aioguardian/issues
  [license-badge]: https://img.shields.io/pypi/l/aioguardian.svg
  [license]: https://github.com/bachya/aioguardian/blob/main/LICENSE
  [maintainability-badge]: https://api.codeclimate.com/v1/badges/e6521f4a50efd222be18/maintainability
  [maintainability]: https://codeclimate.com/github/bachya/aioguardian/maintainability
  [new-issue]: https://github.com/bachya/aioguardian/issues/new
  [new-issue]: https://github.com/bachya/aioguardian/issues/new
  [pypi-badge]: https://img.shields.io/pypi/v/aioguardian.svg
  [pypi]: https://pypi.python.org/pypi/aioguardian
  [version-badge]: https://img.shields.io/pypi/pyversions/aioguardian.svg
  [version]: https://pypi.python.org/pypi/aioguardian


pkgId: 3117f75862153cb4555ae49ad9b07077dcd702510712f321a45ea0a3f9767c91
name: python-aiohappyeyeballs
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: Happy Eyeballs for asyncio
url: https://github.com/aio-libs/aiohappyeyeballs
rpm_license: Python-2.0.1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohappyeyeballs-2.4.0-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://aiohappyeyeballs.readthedocs.io" target="_blank">https://aiohappyeyeballs.readthedocs.io </a>


pkgId: 8a80e69ef17b5447218ff27a7e27515074448ccf1eff1efb0b410f068add89c2
name: python-aioharmony
arch: src
version: 0.2.10
epoch: 0
release: 1
summary: Asyncio Python library for connecting to and controlling the Logitech Harmony
url: https://github.com/ehendrix23/aioharmony
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioharmony-0.2.10-1.src.rpm
checksum_type: sha256
description:
  Python library for programmatically using a Logitech Harmony Link or Ultimate Hub.
  This library originated from `iandday/pyharmony <https://github.com/iandday/pyharmony>`__ which was a fork
  of `bkanuka/pyharmony <https://github.com/bkanuka/pyharmony>`__ with the intent to:
  - Make the harmony library asyncio
  - Ability to provide one's own custom callbacks to be called
  - Automatic reconnect, even if re-connection cannot be established for a time
  - More easily get the HUB configuration through API call
  - Additional callbacks: connect, disconnect, HUB configuration updated
  - Using unique msgid's ensuring that responses from the HUB are correctly managed.


pkgId: 300b1da0479e4b3999f62dc5113c866e3dcf7b93122e177fe8b42c1a4380af7c
name: python-aiohere
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Asynchronous Python client for the HERE API
url: http://github.com/eifinger/aiohere
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohere-2.2.0-1.src.rpm
checksum_type: sha256
description:
  Asynchronous Python client for the HERE API

  Based on [herepy](https://github.com/abdullahselek/HerePy)

  [![GitHub Actions](https://github.com/eifinger/aiohere/workflows/CI/badge.svg)](https://github.com/eifinger/aiohere/actions?workflow=CI)
  [![PyPi](https://img.shields.io/pypi/v/aiohere.svg)](https://pypi.python.org/pypi/aiohere)
  [![PyPi](https://img.shields.io/pypi/l/aiohere.svg)](https://github.com/eifinger/aiohere/blob/master/LICENSE)
  [![codecov](https://codecov.io/gh/eifinger/aiohere/branch/master/graph/badge.svg)](https://codecov.io/gh/eifinger/aiohere)
  [![Downloads](https://pepy.tech/badge/aiohere)](https://pepy.tech/project/aiohere)



  ```bash
  pip install aiohere
  ```



  ```python
  from aiohere import AioHere, WeatherProductType

  import asyncio

  API_KEY = ""


  async def main():
      """Show example how to get weather forecast for your location."""
      async with AioHere(api_key=API_KEY) as aiohere:
          response = await aiohere.weather_for_coordinates(
              latitude=49.9836187,
              longitude=8.2329145,
              products=[WeatherProductType.FORECAST_7DAYS_SIMPLE],
          )
          lowTemperature = response["dailyForecasts"][0]["forecasts"][0]["lowTemperature"]
          highTemperature = response["dailyForecasts"][0]["forecasts"][0][
              "highTemperature"
          ]
          weekday = response["dailyForecasts"][0]["forecasts"][0]["weekday"]

          print(
              f"Temperature on {weekday} will be between {lowTemperature}°C and {highTemperature}°C"
          )


  if __name__ == "__main__":
      loop = asyncio.new_event_loop()
      loop.run_until_complete(main())
  ```

  <a href="https://www.buymeacoffee.com/eifinger" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/black_img.png" alt="Buy Me A Coffee" style="height: auto !important;width: auto !important;" ></a><br>


pkgId: f1ff95f2fdd51c9611a43cb10410b116e7fccc80e8e13673c07bb441edcc993d
name: python-aiohomeconnect
arch: src
version: 0.2.11
epoch: 0
release: 1
summary: An asyncio client for the Home Connect API.
url: https://github.com/MartinHjelmare/aiohomeconnect
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohomeconnect-0.2.11-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://aiohomeconnect.readthedocs.io" target="_blank">https://aiohomeconnect.readthedocs.io </a>


pkgId: 90c5e25df8c4e87f32a3dd1f85bc2f313091c5cf819329cd33b1fd979b158ad9
name: python-aiohomekit
arch: src
version: 3.2.3
epoch: 0
release: 1
summary: An asyncio HomeKit client
url: https://github.com/Jc2k/aiohomekit
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohomekit-3.2.3-1.src.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/Jc2k/aiohomekit/workflows/CI/badge.svg?event=push) [![codecov](https://codecov.io/gh/Jc2k/aiohomekit/branch/master/graph/badge.svg)](https://codecov.io/gh/Jc2k/aiohomekit)

  This library implements the HomeKit protocol for controlling Homekit accessories using asyncio.

  It's primary use is for with Home Assistant. We target the same versions of python as them and try to follow their code standards.

  At the moment we don't offer any API guarantees. API stability and documentation will happen after we are happy with how things are working within Home Assistant.



  `aiohomekit` is primarily for use with Home Assistant. Lots of users are using it with devices from a wide array of vendors. As a community open source project we do not have the hardware or time resources to certify every device with multiple vendors projects. We may be conservative about larger changes or changes that are low level. We do ask where possible that any changes should be tested with a certified HomeKit implementations of shipping products, not just against emulators or other uncertified implementations.

  Because API breaking changes would hamper our ability to quickly update Home Assistant to the latest code, if you can please submit a PR to update [homekit_controller](https://github.com/home-assistant/core/tree/dev/homeassistant/components/homekit_controller) too. If they don't your PR maybe on hold until someone is available to write such a PR.

  Please bear in mind that some shipping devices interpret the HAP specification loosely. In general we prefer to match the behaviour of real HAP controllers even where their behaviour is not strictly specified. Here are just some of the kinds of problems we've had to work around:

  * Despite the precise formatting of JSON being unspecified, there are devices in the wild that cannot handle spaces when parsing JSON. For example, `{"foo": "bar"}` vs `{"foo":"bar"}`. This means we never use a "pretty" encoding of JSON.
  * Despite a boolean being explicitly defined as `0`, `1`, `true` or `false` in the spec, some devices only support 3 of the 4. This means booleans must be encoded as `0` or `1`.
  * Some devices have shown themselves to be sensitive to headers being missing, in the wrong order or if there are extra headers. So we ensure that only the headers iOS sends are present, and that the casing and ordering is the same.
  * Some devices are sensitive to a HTTP message being split into separate TCP packets. So we take care to only write a full message to the network stack.

  And so on. As a rule we need to be strict about what we send and loose about what we receive.



  `aiohomekit` is primarily tested via Home Assistant with a Phillips Hue bridge and an Eve Extend bridge. It is known to work to some extent with many more devices though these are not currently explicitly documented anywhere at the moment.

  You can look at the problems your device has faced in the home-assistant [issues list](https://github.com/home-assistant/core/issues?q=is%3Aopen+is%3Aissue+label%3A%22integration%3A+homekit_controller%22).





  It's published on pypi as `aiohomekit` but its still under early development - proceed with caution.

  The main consumer of the API is the [homekit_controller](https://github.com/home-assistant/core/tree/dev/homeassistant/components/homekit_controller) in Home Assistant so that's the best place to get a sense of the API.



  No. Eventually we hope to via [aioble](https://github.com/detectlabs/aioble) which provides an asyncio bluetooth abstraction that works on Linux, macOS and Windows.



  No, this is just the client part. You should use one the of other implementations:

   * [homekit_python](https://github.com/jlusiardi/homekit_python/) (this is used a lot during aiohomekit development)
   * [HAP-python](https://github.com/ikalchev/HAP-python)



  At the time of writing this is the only python 3.7/3.8 asyncio HAP client with events support.



  Where possible aiohomekit uses libraries that are easy to install with pip, are ready available as wheels (including on Raspberry Pi via piwheels), are cross platform (including Windows) and are already used by Home Assistant. They should not introduce hard dependencies on uncommon system libraries. The intention here is to avoid any difficulty in the Home Assistant build process.

  People are often alarmed at the hand rolled HTTP code and suggest using an existing HTTP library like `aiohttp`. High level HTTP libraries are pretty much a non-starter because:

  * Of the difficulty of adding in HAP session security without monkey patches.
  * They don't expect responses without requests (i.e. events).
  * As mentioned above, some of these devices are very sensitive. We don't care if your change is compliant with every spec if it still makes a real world device cry. We are not in a position to demand these devices be fixed. So instead we strive for byte-for-byte accuracy on our write path. Any library would need to give us that flexibility.
  * Some parts of the responses are actually not HTTP, even though they look it.

  We are also just reluctant to make a change that large for something that is working with a lot of devices. There is a big chance of introducing a regression.

  Of course a working proof of concept (using a popular well maintained library) that has been tested with something like a Tado internet bridge (including events) would be interesting.



  This library wouldn't have been possible without homekit_python, a synchronous implementation of both the client and server parts of HAP.


pkgId: 2f0557603c12a923aac4a01170cff0ef6d78baf17ec21466837bca42a89ae6fd
name: python-aiohttp-asgi
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Adapter to running ASGI applications on aiohttp
url: https://github.com/mosquito/aiohttp-asgi
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-asgi-0.5.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - License](https://img.shields.io/pypi/l/aiohttp-asgi)](https://pypi.org/project/aiohttp-asgi) [![Wheel](https://img.shields.io/pypi/wheel/aiohttp-asgi)](https://pypi.org/project/aiohttp-asgi) [![PyPI](https://img.shields.io/pypi/v/aiohttp-asgi)](https://pypi.org/project/aiohttp-asgi) [![PyPI](https://img.shields.io/pypi/pyversions/aiohttp-asgi)](https://pypi.org/project/aiohttp-asgi) [![Coverage Status](https://coveralls.io/repos/github/mosquito/aiohttp-asgi/badge.svg?branch=master)](https://coveralls.io/github/mosquito/aiohttp-asgi?branch=master) ![tox](https://github.com/mosquito/aiohttp-asgi/workflows/tox/badge.svg?branch=master)
  This module provides a way to use any ASGI compatible frameworks and aiohttp together.


pkgId: b3e894b0e40fd066f38d12232181016b85a023af6ecc0227102df9b821189ecd
name: python-aiohttp-asynctools
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Some function and classes to help you deal with aiohttp sessions
url: https://github.com/cglacet/aiohttp-sessions-helpers
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-asynctools-0.1.3-1.src.rpm
checksum_type: sha256
description:
  [![Travis status](https://travis-ci.com/cglacet/aiohttp-sessions-helpers.svg?branch=master)](https://travis-ci.com/cglacet/aiohttp-sessions-helpers)


  Some function and classes to help you deal with aiohttp client sessions. This is made after this [discussion](https://github.com/aio-libs/aiohttp/pull/1468). This works for decorating both coroutines and asynchronous generators methods.



  ```bash
  pip install aiohttp-asynctools
  ```



  Automatically attach an `aiohttp.ClientSession` object to your class in a fast and clean way with the following 3 steps:

  1. Import `asynctools`
  2. Make your class extend `asynctools.AbstractSessionContainer`
  3. Decorate asynchronous methods/generators with `@asynctools.attach_session` to attach a `session` argument.

  Optionaly, you can also cutomize the instanciation of `AbstractSessionContainer` in your `__init__` method.
  Here is what it looks like for a simple example using a [math API](http://api.mathjs.org/v4):

  ```python
  import asynctools  # 1.

  MATH_API_URL = "http://api.mathjs.org/v4"

  class MathRequests(asynctools.AbstractSessionContainer):  # 2.

      @asynctools.attach_session  # 3.
      async def get_text(self, url, params, session=None):
          async with session.get(url, params=params) as response:
              return await response.text()

      async def get_square(self, value):
          params = {
              "expr" : f"{value}^2"
          }
          return await self.get_text(MATH_API_URL, params=params)
  ```

  You are now ready to instantiate a `MathRequests` context manager and start requesting the math service using a single `aiohttp` `session` (the session is hidden from the `MathRequests` user). Here is how you could build a math server using the new class (basically we wrote a wrapper for the Math API and now we expose our own API).

  ```python
  from aiohttp import web
  routes = web.RouteTableDef()

  @routes.get('/squares')
  async def squares(request):
      values = request.query['values'].split(',')

      async with MathRequests() as maths:
          squares = await asyncio.gather(*(maths.get_square(v) for v in values))

      return {
          'values': values,
          'squares': squares,
      }

  maths_app = web.Application()
  maths_app.add_routes(routes)

  if __name__ == "__main__":
      web.run_app(app)
  ```

  We are now ready to test:
  ```bash
  curl 'http://localhost:8080/squares?values=1,2,3,4,5,6,7,8,9,10'
  ```

  Which should output:
  ```json
  {
    "values": ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
    "results": ["1", "4", "9", "16", "25", "36", "49", "64", "81", "100"]
  }
  ```

  A more complete example can be found in [example](example).





  The goal is to help aiohttp users to build classes that will contain sessions object in an efficient/clean way.



  If you want to build class that will make requests using **aiohttp client**, at some point you'll have to deal with sessions.
  The [quickstart guide for aiohttp client](https://aiohttp.readthedocs.io/en/stable/client_quickstart.html#make-a-request) has an important note about them.

  >```python
  >import aiohttp
  >
  >async with aiohttp.ClientSession() as session:
  >    async with session.get('http://httpbin.org/get') as resp:
  >        print(resp.status)
  >        print(await resp.text())
  >```
  >
  > ...
  >
  > ### Note
  > Don’t create a session per request. Most likely you need a session per application which performs all requests altogether.
  >
  > More complex cases may require a session per site, e.g. one for Github and other one for Facebook APIs. Anyway making a session for every request is a **very bad** idea.
  >
  >A session contains a connection pool inside. Connection reusage and keep-alives (both are on by default) may speed up total performance.

  The goal is to have a single session attached to a given object, this is what this module offers with only 3 (very simple) lines of code.



  The module provides an abstract class `AbstractSessionContainer` and a method decorator `attach_session` that you'll have to use to automatically add session management to an existing class.

  Say you have a class `MathRequests` that has a single method `get_square` that returns the square value of the given parameter using an `aiohttp.get` request to the math API service located at http://api.mathjs.org/v4. Here is what your class look like for now:

  ```python
  import asyncio, aiohttp
  routes = aiohttp.web.RouteTableDef()

  class MathRequests:
      async def get_text(self, url, params):
          
          async with aiohttp.ClientSession() as session:
              async with session.get(url, params=params) as response:
                  return await response.text()
      async def get_square(self, value):
          return await self.get_text("http://api.mathjs.org/v4", params={'expr' : '{}^2'.format(value)})

  @routes.get('/squares')
  async def index(request):
      tasks = []
      data = request.query
      values = data['values'].split(',')
      maths = MathRequests()
      results = await asyncio.gather(*[ maths.get_square(v) for v in values ])
      return web.json_response({ 'values':values, 'results':results })

  maths_app = aiohttp.web.Application()
  maths_app.add_routes(routes)
  ```
  As `aiohttp` documentation says, this is a bad idea to implement `MathRequests` this way, we need to share a single session for all `get_square` requests.

  A simple solution to this would be to store a client session object within `MathRequests`, which you could initiate in the `__init__` method. Saddly this is not a very clean solution as aiohttp sessions should be instantiated in a synchronous way (outside the even loop). See [aiohttp#1468](https://github.com/aio-libs/aiohttp/pull/1468) for more information about _creation a session outside of coroutine_.

  Here is the final solution using the provided module `asynctools`:
  ```python
  import asyncio
  import asynctools # 1) Import


  class MathRequests(asynctools.AbstractSessionContainer):
      def __init__(self):
          
          super().__init__(raise_for_status=True)
      
      @asynctools.attach_session
      async def get_text(self, url, params, session=None):  # 4) Add the 'session' argument
          async with session.get(url, params=params) as response:
              return await response.text()
      async def get_square(self, value):
          return await self.get_text("http://api.mathjs.org/v4", params={'expr' : '{}^2'.format(value)})

  from aiohttp import web
  routes = web.RouteTableDef()

  @routes.get('/squares')
  async def index(request):
      tasks = []
      data = request.query
      values = data['values'].split(',')
      async with MathRequests() as maths: # Use the object as a context manager (async with <context_manager> as <name>)
          results = await asyncio.gather(*[ maths.get_square(v) for v in values ])
      return web.json_response({ 'values':values, 'results':results })

  maths_app = web.Application()
  maths_app.add_routes(routes)
  ```

  Using the `MathRequests` as a [context manager](https://docs.python.org/3/library/stdtypes.html#typecontextmanager) is the best option (as it will make sure the session is correctly started and closed), but it's not the only option, you can also keep your code as it was before:
  ```python
  @routes.get('/squares')
  async def index(request):
      tasks = []
      data = request.query
      values = data['values'].split(',')
      maths = MathRequests()
      results = await asyncio.gather(*[ maths.get_square(v) for v in values ])
      return web.json_response({ 'values':values, 'results':results })
  ```
  In this case, no session is attached to the `maths` object and every call to `get_square` will use a different session (which is as bad as it was with the old version of `MathRequests`). What you can do to avoid that is to **explicitly open a "math session"** which will make all `get_square` calls to use the same session (also, don't forget to close the session when you are done):
  ```python
  @routes.get('/maths')
  async def index(request):
      tasks = []
      data = request.query
      values = data['values'].split(',')
      maths = MathRequests()
      maths.start_session()
      results = await asyncio.gather(*[ maths.get_square(v) for v in values ])
      maths.close_session()
      return web.json_response({ 'values':values, 'results':results })
  ```


pkgId: c1e004c62770cfceee60771058c44aae5dde41a992f1ef158e0f2a45e9e36496
name: python-aiohttp-basicauth
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: HTTP basic authentication middleware for aiohttp 3.0+
url: https://github.com/romis2012/aiohttp-basicauth
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-basicauth-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/romis2012/aiohttp-basicauth/actions/workflows/ci.yml/badge.svg)](https://github.com/romis2012/aiohttp-basicauth/actions/workflows/ci.yml)
  [![Coverage Status](https://codecov.io/gh/romis2012/aiohttp-basicauth/branch/master/graph/badge.svg)](https://codecov.io/gh/romis2012/aiohttp-basicauth)
  [![PyPI version](https://badge.fury.io/py/aiohttp-basicauth.svg?_=a)](https://badge.fury.io/py/aiohttp-basicauth)

  HTTP basic authentication middleware for aiohttp 3.0+.
  Inspired by [Flask-BasicAuth](https://github.com/jpvanhal/flask-basicauth).


  - Python >= 3.7
  - aiohttp >= 3.0


  ```
  pip install aiohttp_basicauth
  ```



  ```python
  from aiohttp import web
  from aiohttp_basicauth import BasicAuthMiddleware


  auth = BasicAuthMiddleware(username='user', password='password')
  app = web.Application(middlewares=[auth])

  web.run_app(app, host='127.0.0.1', port=80)
  ```


  ```python
  from aiohttp import web
  from aiohttp_basicauth import BasicAuthMiddleware

  auth = BasicAuthMiddleware(username='user', password='password', force=False)


  async def public_view(request):
      return web.Response(text='Public view')


  @auth.required
  async def secret_view(request):
      return web.Response(text='Secret view')


  app = web.Application(middlewares=[auth])

  app.router.add_route('GET', '/public', public_view)
  app.router.add_route('GET', '/secret', secret_view)

  web.run_app(app, host='127.0.0.1', port=80)
  ```



  You can override ```check_credentials``` method to implement more complex user verification logic:

  ```python
  from aiohttp import web
  from aiohttp_basicauth import BasicAuthMiddleware


  class CustomBasicAuth(BasicAuthMiddleware):
      async def check_credentials(self, username, password, request):
          
          return username == 'user' and password == 'password'


  auth = CustomBasicAuth()
  app = web.Application(middlewares=[auth])

  web.run_app(app, host='127.0.0.1', port=80)
  ```


pkgId: 457b81673ca910c7890ef06e5e4fb3e9e78a7f1cf241d9caf97f5c7a921c2311
name: python-aiohttp-client-cache
arch: src
version: 0.12.3
epoch: 0
release: 1
summary: Persistent cache for aiohttp requests
url: https://github.com/requests-cache/aiohttp-client-cache
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-client-cache-0.12.3-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/requests-cache/aiohttp-client-cache/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/requests-cache/aiohttp-client-cache/actions)
  [![Documentation Status](https://img.shields.io/readthedocs/aiohttp-client-cache/latest?label=docs)](https://aiohttp-client-cache.readthedocs.io/en/stable/)
  [![Codecov](https://codecov.io/gh/requests-cache/aiohttp-client-cache/branch/main/graph/badge.svg?token=I6PNLYTILM)](https://codecov.io/gh/requests-cache/aiohttp-client-cache)
  [![PyPI](https://img.shields.io/pypi/v/aiohttp-client-cache?color=blue)](https://pypi.org/project/aiohttp-client-cache)
  [![Conda](https://img.shields.io/conda/vn/conda-forge/aiohttp-client-cache?color=blue)](https://anaconda.org/conda-forge/aiohttp-client-cache)
  [![PyPI - Python Versions](https://img.shields.io/pypi/pyversions/aiohttp-client-cache)](https://pypi.org/project/aiohttp-client-cache)
  [![PyPI - Format](https://img.shields.io/pypi/format/aiohttp-client-cache?color=blue)](https://pypi.org/project/aiohttp-client-cache)

  **aiohttp-client-cache** is an async persistent cache for [aiohttp](https://docs.aiohttp.org)
  client requests, based on [requests-cache](https://github.com/reclosedev/requests-cache).



  - **Ease of use:** Use as a [drop-in replacement](https://aiohttp-client-cache.readthedocs.io/en/stable/user_guide.html)
    for `aiohttp.ClientSession`
  - **Customization:** Works out of the box with little to no config, but with plenty of options
    available for customizing cache
    [expiration](https://aiohttp-client-cache.readthedocs.io/en/stable/user_guide.html#cache-expiration)
    and other [behavior](https://aiohttp-client-cache.readthedocs.io/en/stable/user_guide.html#cache-options)
  - **Persistence:** Includes several [storage backends](https://aiohttp-client-cache.readthedocs.io/en/stable/backends.html):
    SQLite, DynamoDB, MongoDB, DragonflyDB and Redis.



  First, install with pip (python 3.8+ required):

  ```bash
  pip install aiohttp-client-cache[all]
  ```

  **Note:**
  Adding `[all]` will install optional dependencies for all supported backends. When adding this
  library to your application, you can include only the dependencies you actually need; see individual
  backend docs and [pyproject.toml](https://github.com/requests-cache/aiohttp-client-cache/blob/main/pyproject.toml)
  for details.



  Next, use [aiohttp_client_cache.CachedSession](https://aiohttp-client-cache.readthedocs.io/en/stable/modules/aiohttp_client_cache.session.html#aiohttp_client_cache.session.CachedSession)
  in place of [aiohttp.ClientSession](https://docs.aiohttp.org/en/stable/client_reference.html#aiohttp.ClientSession).
  To briefly demonstrate how to use it:

  **Replace this:**

  ```python
  from aiohttp import ClientSession

  async with ClientSession() as session:
      await session.get('http://httpbin.org/delay/1')
  ```

  **With this:**

  ```python
  from aiohttp_client_cache import CachedSession, SQLiteBackend

  async with CachedSession(cache=SQLiteBackend('demo_cache')) as session:
      await session.get('http://httpbin.org/delay/1')
  ```

  The URL in this example adds a delay of 1 second, simulating a slow or rate-limited website.
  With caching, the response will be fetched once, saved to `demo_cache.sqlite`, and subsequent
  requests will return the cached response near-instantly.



  Several options are available to customize caching behavior. This example demonstrates a few of them:

  ```python

  from aiohttp_client_cache import SQLiteBackend

  cache = SQLiteBackend(
      cache_name='~/.cache/aiohttp-requests.db',  # For SQLite, this will be used as the filename
      expire_after=60*60,                         # By default, cached responses expire in an hour
      urls_expire_after={'*.fillmurray.com': -1}, # Requests for any subdomain on this site will never expire
      allowed_codes=(200, 418),                   # Cache responses with these status codes
      allowed_methods=['GET', 'POST'],            # Cache requests with these HTTP methods
      include_headers=True,                       # Cache requests with different headers separately
      ignored_params=['auth_token'],              # Keep using the cached response even if this param changes
      timeout=2.5,                                # Connection timeout for SQLite backend
  )
  ```



  To learn more, see:

  - [User Guide](https://aiohttp-client-cache.readthedocs.io/en/stable/user_guide.html)
  - [Cache Backends](https://aiohttp-client-cache.readthedocs.io/en/stable/backends.html)
  - [API Reference](https://aiohttp-client-cache.readthedocs.io/en/stable/reference.html)
  - [Examples](https://aiohttp-client-cache.readthedocs.io/en/stable/examples.html)



  If there is a feature you want, if you've discovered a bug, or if you have other general feedback, please
  [create an issue](https://github.com/requests-cache/aiohttp-client-cache/issues/new/choose) for it!


pkgId: 012978ff730aac67d2391c875c8e4d55ec2d45faab4d4189af769c9bbf2ee619
name: python-aiohttp-client-rate-limiter
arch: src
version: 1.0.3
epoch: 0
release: 1
url: https://github.com/peteropensource/aiohttp_rate_limiter
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-client-rate-limiter-1.0.3-1.src.rpm
checksum_type: sha256
summary:
  This is a mini tool that overwrite aiohttp session to provide rate limit function within a same session.

description:
  This is a mini tool that overwrites ClientSession class from aiohttp (https://pypi.org/project/aiohttp/). This subclass introduces rate limter functionality while leaving all the other parent behaviors untouched.

  Example:
  ```python
  import asyncio
  from aiohttp_client_rate_limiter.ClientSession import RateLimitedClientSession

  rl_session = RateLimitedClientSession(
          max_concur=5,
          reqs_per_period=10,
          period_in_secs=60
      )
  tasks = [asyncio.create_task(rl_session.get(f"https://www.google.com/?q={i}", ssl=False)) for i in range(10)]

  await asyncio.gather(*tasks)

  await rl_session.close()
  ```

  Or, we could simply do this, using the native context manager as provided by aiohttp:
  ```python
  import asyncio
  from aiohttp_client_rate_limiter.ClientSession import RateLimitedClientSession

  async with RateLimitedClientSession(
      max_concur=60,
      reqs_per_period=5,
      period_in_secs=10
  ) as rl_session:
      tasks = [asyncio.create_task(rl_session.get(f"https://www.google.com/?q={i}", ssl=False)) for i in range(10)]
      await asyncio.gather(*tasks)
  ```
  The above example could provide a steady rate of 10 requests/60 seconds at the maximum concurrency of 5.


pkgId: a86981f748424f4f357f563d178500e52683ef4d9f0523e161cd972e7c15d9a9
name: python-aiohttp-csrf
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: CSRF protection for aiohttp-server
url: https://github.com/TensorTom/aiohttp-csrf
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-csrf-0.1.1-1.src.rpm
checksum_type: sha256
description:
  The library provides csrf (xsrf) protection for [aiohttp.web](https://docs.aiohttp.org/en/latest/web.html).
  **Breaking Change:** New in 0.1.0 is Blake3 hashes are used by default. This means you must pass `secret_phrase` to
  `aiohttp_csrf.storage.SessionStorage`
  **note:** The package [aiohttp-csrf-fixed](https://pypi.org/project/aiohttp-csrf-fixed) is aiohttp_csrf 0.0.2 +
  [this commit](https://github.com/oplik0/aiohttp-csrf/commit/b1bd9207f43a2abf30e32e72ecdb10983a251823). The maintainer
  didn't submit a PR so I just saw it by chance. I haven't had  time to closely examine it but I think it's just removing
  the HTTP security error that happens if no CSRF is provided. Why do that? An HTTP error is good because it tells the
  client what happened and lets you handle it by middleware.
  __0.1.1:__ Converted `@aiohttp_csrf.csrf_exempt` decorator to a co-routine to make it compatible with latest aiohttp.
  ![image](https://img.shields.io/travis/wikibusiness/aiohttp-csrf.svg%0A%20:target:%20https://travis-ci.org/wikibusiness/aiohttp-csrf)


pkgId: ae179dc94d33698b7d9a588424055e2fdceb87d0d6f9476e161044b554e0a765
name: python-aiohttp-debugtoolbar
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: debugtoolbar for aiohttp
url: https://github.com/aio-libs/aiohttp_debugtoolbar
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-debugtoolbar-0.6.1-1.src.rpm
checksum_type: sha256
description:
  **aiohttp_debugtoolbar** provides a debug toolbar for your aiohttp_
  web application.  Library is port of pyramid_debugtoolbar_ and
  still in early development stages. Basic functionality has been
  ported:
  * basic panels
  * intercept redirects
  * intercept and pretty print exception
  * interactive python console
  * show source code


pkgId: 3581ab1c482c6cd268772ff4b37fd89f3fb60db20edfa4d84d59ebb3f390d032
name: python-aiohttp-deps
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: Dependency injection for AioHTTP
url: https://github.com/taskiq-python/aiohttp-deps
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-deps-1.1.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aiohttp-deps?style=for-the-badge)](https://pypi.org/project/aiohttp-deps/)
  [![PyPI](https://img.shields.io/pypi/v/aiohttp-deps?style=for-the-badge)](https://pypi.org/project/aiohttp-deps/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/aiohttp-deps?style=for-the-badge)](https://pypistats.org/packages/aiohttp-deps)




  This project was initially created to show the abillities of [taskiq-dependencies](https://github.com/taskiq-python/taskiq-dependencies) project, which is used by [taskiq](https://github.com/taskiq-python/taskiq) to provide you with the best experience of sending distributed tasks.

  This project adds [FastAPI](https://github.com/tiangolo/fastapi)-like dependency injection to your [AioHTTP](https://github.com/aio-libs/aiohttp) application and swagger documentation based on types.

  To start using dependency injection, just initialize the injector.

  ```python
  from aiohttp import web
  from aiohttp_deps import init as deps_init


  app = web.Application()


  app.on_startup.append(deps_init)

  web.run_app(app)

  ```


  If you use mypy, then we have a custom router with propper types.


  ```python
  from aiohttp import web
  from aiohttp_deps import init as deps_init
  from aiohttp_deps import Router

  router = Router()


  @router.get("/")
  async def handler():
      return web.json_response({})


  app = web.Application()

  app.router.add_routes(router)

  app.on_startup.append(deps_init)

  web.run_app(app)

  ```

  Also, you can nest routers with prefixes,

  ```python
  api_router = Router()

  memes_router = Router()

  main_router = Router()

  main_router.add_routes(api_router, prefix="/api")
  main_router.add_routes(memes_router, prefix="/memes")
  ```



  If you use dependencies in you handlers, we can easily generate swagger for you.
  We have some limitations:
  1. We don't support resolving type aliases if hint is a string.
      If you define variable like this: `myvar = int | None` and then in handler
      you'd create annotation like this: `param: "str | myvar"` it will fail.
      You need to unquote type hint in order to get it work.

  We will try to fix these limitations later.

  To enable swagger, just add it to your startup.

  ```python
  from aiohttp_deps import init, setup_swagger

  app = web.Application()

  app.on_startup.extend([init, setup_swagger()])
  ```



  You can define schema for responses using dataclasses or
  pydantic models. This would not affect handlers in any way,
  it's only for documentation purposes, if you want to actually
  validate values your handler returns, please write your own wrapper.

  ```python
  from dataclasses import dataclass

  from aiohttp import web
  from pydantic import BaseModel

  from aiohttp_deps import Router, openapi_response

  router = Router()


  @dataclass
  class Success:
      data: str


  class Unauthorized(BaseModel):
      why: str


  @router.get("/")
  @openapi_response(200, Success, content_type="application/xml")
  @openapi_response(200, Success)
  @openapi_response(401, Unauthorized, description="When token is not correct")
  async def handler() -> web.Response:
      ...
  ```

  This example illustrates how much you can do with this decorator. You
  can have multiple content-types for a single status, or you can have different
  possble statuses. This function is pretty simple and if you want to make
  your own decorator for your responses, it won't be hard.




  By default this library provides only two injectables. `web.Request` and `web.Application`.

  ```python

  async def handler(app: web.Application = Depends()): ...

  async def handler2(request: web.Request = Depends()): ...

  ```

  It's super useful, because you can use these dependencies in
  any other dependency. Here's a more complex example of how you can use this library.


  ```python
  from aiohttp_deps import Router, Depends
  from aiohttp import web

  router = Router()


  async def get_db_session(app: web.Application = Depends()):
      async with app[web.AppKey("db")] as sess:
          yield sess


  class MyDAO:
      def __init__(self, session=Depends(get_db_session)):
          self.session = session

      async def get_objects(self) -> list[object]:
          return await self.session.execute("SELECT 1")


  @router.get("/")
  async def handler(db_session: MyDAO = Depends()):
      objs = await db_session.get_objects()
      return web.json_response({"objects": objs})

  ```

  If you do something like this, you would never think about initializing your DAO. You can just inject it and that's it.




  This library also provides you with some default dependencies that can help you in building the best web-service.



  To parse json, create a pydantic model and add a dependency to your handler.


  ```python
  from aiohttp import web
  from pydantic import BaseModel
  from aiohttp_deps import Router, Json, Depends

  router = Router()


  class UserInfo(BaseModel):
      name: str


  @router.post("/users")
  async def new_data(user: UserInfo = Depends(Json())):
      return web.json_response({"user": user.model_dump()})

  ```

  This dependency automatically validates data and send
  errors if the data doesn't orrelate with schema or body is not a valid json.

  If you want to make this data optional, just mark it as optional.

  ```python
  @router.post("/users")
  async def new_data(user: Optional[UserInfo] = Depends(Json())):
      if user is None:
          return web.json_response({"user": None})
      return web.json_response({"user": user.model_dump()})

  ```



  You can get and validate headers using `Header` dependency.

  Let's try to build simple example for authorization.

  ```python
  from aiohttp_deps import Router, Header, Depends
  from aiohttp import web

  router = Router()


  def decode_token(authorization: str = Depends(Header())) -> str:
      if authorization == "secret":
          
          
          return authorization
      raise web.HTTPUnauthorized()


  @router.get("/secret_data")
  async def new_data(token: str = Depends(decode_token)) -> web.Response:
      return web.json_response({"secret": "not a secret"})

  ```

  As you can see, header name to parse is equal to the
  name of a parameter that introduces Header dependency.

  If you want to use some name that is not allowed in python, or just want to have different names, you can use alias. Like this:

  ```python
  def decode_token(auth: str = Depends(Header(alias="Authorization"))) -> str:
  ```

  Headers can also be parsed to types. If you want a header to be parsed as int, just add the typehint.

  ```python
  def decode_token(meme_id: int = Depends(Header())) -> str:
  ```

  If you want to get list of values of one header, use parameter `multiple=True`.

  ```python
  def decode_token(meme_id: list[int] = Depends(Header(multiple=True))) -> str:

  ```

  And, of course, you can provide this dependency with default value if the value from user cannot be parsed for some reason.

  ```python
  def decode_token(meme_id: str = Depends(Header(default="not-a-secret"))) -> str:
  ```




  You can depend on `Query` to get and parse query parameters.

  ```python
  from aiohttp_deps import Router, Query, Depends
  from aiohttp import web

  router = Router()


  @router.get("/shop")
  async def shop(item_id: str = Depends(Query())) -> web.Response:
      return web.json_response({"id": item_id})

  ```

  the name of the parameter is the same as the name of function parameter.

  The Query dependency is acually the same as the Header dependency, so everything about the `Header` dependency also applies to `Query`.



  If you use views as handlers, please use View class from `aiohttp_deps`, otherwise the magic won't work.

  ```python
  from aiohttp_deps import Router, View, Depends
  from aiohttp import web

  router = Router()


  @router.view("/view")
  class MyView(View):
      async def get(self, app: web.Application = Depends()):
          return web.json_response({"app": str(app)})

  ```




  Now you can easiy get and validate form data from your request.
  To make the magic happen, please add `arbitrary_types_allowed` to the config of your model.


  ```python
  import pydantic
  from aiohttp_deps import Router, Depends, Form
  from aiohttp import web

  router = Router()


  class MyForm(pydantic.BaseModel):
      id: int
      file: web.FileField

      model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)


  @router.post("/")
  async def handler(my_form: MyForm = Depends(Form())):
      with open("my_file", "wb") as f:
          f.write(my_form.file.file.read())
      return web.json_response({"id": my_form.id})

  ```



  If you have path variables, you can also inject them in your handler.

  ```python
  from aiohttp_deps import Router, Path, Depends
  from aiohttp import web

  router = Router()


  @router.get("/view/{var}")
  async def my_handler(var: str = Depends(Path())):
      return web.json_response({"var": var})

  ```




  This dependency is used to add additional swagger fields to the endpoint's swagger
  that is using this dependency. It might be even indirect dependency.

  You can check how this thing can be used in our [examples/swagger_auth.py](https://github.com/taskiq-python/aiohttp-deps/tree/master/examples/swagger_auth.py).




  Sometimes for tests you don't want to calculate actual functions
  and you want to pass another functions instead.

  To do so, you can add "dependency_overrides" or "values_overrides" to the aplication's state.
  These values should be dicts. The keys for these values can be found in `aiohttp_deps.keys` module.

  Here's an example.

  ```python
  def original_dep() -> int:
      return 1

  class MyView(View):
      async def get(self, num: int = Depends(original_dep)):
          """Nothing."""
          return web.json_response({"request": num})
  ```

  Imagine you have a handler that depends on some function,
  but instead of `1` you want to have `2` in your tests.

  To do it, jsut add `dependency_overrides` somewhere,
  where you create your application. And make sure that keys
  of that dict are actual function that are being replaced.

  ```python
  from aiohttp_deps import VALUES_OVERRIDES_KEY

  my_app[VALUES_OVERRIDES_KEY] = {original_dep: 2}
  ```

  But `values_overrides` only overrides returned values. If you want to
  override functions, you have to use `dependency_overrides`. Here's an example:

  ```python
  from aiohttp_deps import DEPENDENCY_OVERRIDES_KEY

  def replacing_function() -> int:
      return 2


  my_app[DEPENDENCY_OVERRIDES_KEY] = {original_dep: replacing_function}
  ```

  The cool point about `dependency_overrides`, is that it recalculates graph and
  you can use dependencies in function that replaces the original.


pkgId: d652d46a622a9e3c006af8344988ee1641f80e0421b632cd6e0685e79b3b29d1
name: python-aiohttp-devtools
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Dev tools for aiohttp
url: https://github.com/aio-libs/aiohttp-devtools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-devtools-1.1.2-1.src.rpm
checksum_type: sha256
description:
  |Coverage| |pypi| |license|
  Dev tools for `aiohttp`_.
  **aiohttp-devtools** provides a number of tools useful when developing applications with aiohttp and associated
  libraries.


pkgId: ee828eb1b83f0ecaf7939e582d9cba1f9f6870002af3927e62fc44848480dc3e
name: python-aiohttp-fast-url-dispatcher
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A faster URL dispatcher for aiohttp
url: https://github.com/bdraco/aiohttp-fast-url-dispatcher
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-fast-url-dispatcher-0.3.1-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://aiohttp-fast-url-dispatcher.readthedocs.io" target="_blank">https://aiohttp-fast-url-dispatcher.readthedocs.io </a>


pkgId: fd4ed6b385f1078d995ac56f52bca8e1d5621e660a2242df0430d79c2d7fb0b3
name: python-aiohttp-graphql
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Adds GraphQL support to your aiohttp application
url: https://github.com/graphql-python/aiohttp-graphql
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-graphql-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Adds [GraphQL] support to your [aiohttp] application.

  Based on [flask-graphql] by [Syrus Akbary] and [sanic-graphql] by [Sergey Porivaev].

  [![PyPI version](https://badge.fury.io/py/aiohttp-graphql.svg)](https://badge.fury.io/py/aiohttp-graphql)
  [![Build Status](https://travis-ci.com/graphql-python/aiohttp-graphql.svg?branch=master)](https://github.com/graphql-python/aiohttp-graphql)
  [![Coverage Status](https://codecov.io/gh/graphql-python/aiohttp-graphql/branch/master/graph/badge.svg)](https://github.com/graphql-python/aiohttp-graphql)


  Just use the `GraphQLView` view from `aiohttp_graphql`

  ```python
  from aiohttp_graphql import GraphQLView

  GraphQLView.attach(app, schema=Schema, graphiql=True)


  GraphQLView.attach(app, schema=Schema, batch=True)
  ```

  This will add a `/graphql` endpoint to your app (customizable by passing `route_path='/mypath'` to `GraphQLView.attach`).

  Note: `GraphQLView.attach` is just a convenience function, and the same functionality can be achieved with

  ```python
  gql_view = GraphQLView(schema=Schema, **kwargs)
  app.router.add_route('*', gql_view, name='graphql')
  ```

  It's worth noting that the the "view function" of `GraphQLView` is contained in `GraphQLView.__call__`. So, when you create an instance, that instance is callable with the request object as the sole positional argument. To illustrate:

  ```python
  gql_view = GraphQLView(schema=Schema, **kwargs)
  gql_view(request)  # <-- the instance is callable and expects a `aiohttp.web.Request` object.
  ```


  -   `schema`: The `GraphQLSchema` object that you want the view to execute when it gets a valid request.
  -   `executor`: The `Executor` that you want to use to execute queries. If an `AsyncioExecutor` instance is provided, performs queries asynchronously within executorâ€™s loop.
  -   `root_value`: The `root_value` you want to provide to `executor.execute`.
  -   `context`: A value to pass as the `context` to the `graphql()` function. By default is set to `dict` with request object at key `request`.
  -   `pretty`: Whether or not you want the response to be pretty printed JSON.
  -   `graphiql`: If `True`, may present [GraphiQL] when loaded directly from a browser (a useful tool for debugging and exploration).
  -   `graphiql_version`: The version of the provided `graphiql` package.
  -   `graphiql_template`: Inject a Jinja template string to customize GraphiQL.
  -   `middleware`: Custom middleware for [graphql-python].
  -   `batch`: Set the GraphQL view as batch (for using in [Apollo-Client] or [ReactRelayNetworkLayer])
  -   `jinja_env`: Sets jinja environment to be used to process GraphiQL template. If Jinjaâ€™s async mode is enabled (by `enable_async=True`), uses
  `Template.render_async` instead of `Template.render`. If environment is not set, fallbacks to simple regex-based renderer.
  -   `max_age`: sets the response header `Access-Control-Max-Age` for preflight requests
  -   `encoder`: the encoder to use for responses (sensibly defaults to `graphql_server.json_encode`)
  -   `error_formatter`: the error formatter to use for responses (sensibly defaults to `graphql_server.default_format_error`)
  -   `enable_async`: whether `async` mode will be enabled.
  -   `subscriptions`: The [GraphiQL] socket endpoint for using subscriptions in [graphql-ws].



  Testing is done with `pytest`.

  ```bash
  git clone https://github.com/graphql-python/aiohttp-graphql
  cd aiohttp-graphql

  python3.6 -m venv env && source env/bin/activate  # for example
  pip install -e .[test]
  pytest
  ```

  The tests, while modeled after sanic-graphql's tests, have been entirely refactored to take advantage of `pytest-asyncio`, conform with PEP-8, and increase readability with pytest fixtures. For usage tests, please check them out.



  Copyright for portions of project [aiohttp-graphql] are held by [Syrus Akbary] as part of project [flask-graphql] and [sanic-graphql] as part of project [Sergey Porivaev]. All other claims to this project [aiohttp-graphql] are held by [Devin Fee].

  This project is licensed under the MIT License.

    [GraphQL]: http://graphql.org/
    [aiohttp]: https://github.com/aio-libs/aiohttp/
    [flask-graphql]: https://github.com/graphql-python/flask-graphql
    [sanic-graphql]: https://github.com/graphql-python/sanic-graphql
    [Syrus Akbary]: https://github.com/syrusakbary
    [Sergey Porivaev]: https://github.com/grazor
    [GraphiQL]: https://github.com/graphql/graphiql
    [graphql-python]: https://github.com/graphql-python/graphql-core
    [Apollo-Client]: https://www.apollographql.com/docs/react/networking/network-layer/#query-batching
    [Devin Fee]: https://github.com/dfee
    [aiohttp-graphql]: https://github.com/graphql-python/aiohttp-graphql
    [graphql-ws]: https://github.com/graphql-python/graphql-ws


pkgId: 709cd34bf96424c5129c0e2fdb833c08e165a39140ef32ffbb577ae8b6607197
name: python-aiohttp-index
arch: src
version: 0.1
epoch: 0
release: 1
url: https://github.com/crowsonkb/aiohttp_index
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-index-0.1-1.src.rpm
checksum_type: sha256
summary:
  aiohttp.web middleware to serve index files (e.g. index.html) when static directories are requested.

description:
  `aiohttp.web <http://aiohttp.readthedocs.org/en/stable/>`__ middleware to
  serve index files (e.g. index.html) when static directories are requested.


pkgId: 32dcb54bccec4a6331473d833c7ea48d8ae0908ec4f58f806351348badfe372c
name: python-aiohttp-isal
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: isal support for aiohttp
url: https://github.com/bdraco/aiohttp-isal
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-isal-0.3.2-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://aiohttp-isal.readthedocs.io" target="_blank">https://aiohttp-isal.readthedocs.io </a>


pkgId: 2ec186e7aecf170f36995df31c2e70cf50f8903de5c8b0bb97418c103b917436
name: python-aiohttp-json-rpc
arch: src
version: 0.13.3
epoch: 0
release: 1
summary: Implementation JSON-RPC 2.0 server and client using aiohttp on top of websockets transport
url: https://github.com/pengutronix/aiohttp-json-rpc/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-json-rpc-0.13.3-1.src.rpm
checksum_type: sha256
description:
  Implements `JSON-RPC 2.0 Specification <http://www.jsonrpc.org/specification>`_ using `aiohttp <http://aiohttp.readthedocs.org/en/stable/>`_
  +---------------+---------------+
  | Protocol      | Support       |
  +===============+===============+
  | Websocket     | since v0.1    |
  +---------------+---------------+
  | POST          | TODO          |
  +---------------+---------------+
  | GET           | TODO          |
  +---------------+---------------+


pkgId: 38917170150f7ebadbb3d4dd445f62eab5353896a4f3ff0fa2217c8d301f6827
name: python-aiohttp-jwt
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: aiohttp middleware for working with JWT
url: https://github.com/hzlmn/aiohttp-jwt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-jwt-0.6.1-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://pepy.tech/badge/aiohttp-jwt/month)](https://pepy.tech/project/aiohttp-jwt/month)
  [![Build Status](https://travis-ci.org/hzlmn/aiohttp-jwt.svg?branch=master)](https://travis-ci.org/hzlmn/aiohttp-jwt)
  [![codecov](https://codecov.io/gh/hzlmn/aiohttp-jwt/branch/master/graph/badge.svg)](https://codecov.io/gh/hzlmn/aiohttp-jwt)

  The library provides `aiohttp` middleware and helper utils for working with JSON web tokens.

    * Works on Python3.5+
    * MIT License
    * Latest docs [TBD]()
    * Contributions are highly welcome!



   - [Aiohttp >= 2.3.5](https://github.com/aio-libs/aiohttp)
   - [PyJWT](https://github.com/jpadilla/pyjwt)



  ```bash
  $ pip install aiohttp_jwt
  ```


  `server.py`
  ```python
  import jwt
  from aiohttp import web

  from aiohttp_jwt import JWTMiddleware

  sharable_secret = 'secret'


  async def protected_handler(request):
      return web.json_response({'user': request['payload']})


  app = web.Application(
      middlewares=[
          JWTMiddleware(sharable_secret),
      ]
  )

  app.router.add_get('/protected', protected_handler)

  if __name__ == '__main__':
      web.run_app(app)

  ```

  `client.py`
  ```python
  import asyncio

  import aiohttp
  import async_timeout


  async def fetch(session, url, headers=None):
      async with async_timeout.timeout(10):
          async with session.get(url, headers=headers) as response:
              return await response.json()


  async def main():
      async with aiohttp.ClientSession() as session:
          response = await fetch(
              session,
              'http://localhost:8080/protected',
              headers={'Authorization': 'Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6InRlc3QifQ.pyNsXX_vNsUvdt6xu13F1Gs1zGELT4Va8a38eG5svBA'})
          print(response)

  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())

  ```


  - [Basic Example](/example/basic.py)
  - [Permissions control](/example/permissions.py)





  This module inspired by official [auth0/express-jwt](https://github.com/auth0/express-jwt) middleware and
  [express-jwt-permissions](https://github.com/MichielDeMey/express-jwt-permissions) extension.



    For advanced security facilities check [aio-libs/aiohttp_security](https://github.com/aio-libs/aiohttp-security)


  MIT License


pkgId: 32807d107e00e4015a9b2b5377cc6145a9fadb771ca89dff71510042ba51c480
name: python-aiohttp-msal
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Helper Library to use the Microsoft Authentication Library (MSAL) with aiohttp
url: https://github.com/kellerza/aiohttp_msal
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-msal-0.7.1-1.src.rpm
checksum_type: sha256
description:
  Authorization Code Flow Helper. Learn more about auth-code-flow at
  <https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-auth-code-flow>

  Async based OAuth using the Microsoft Authentication Library (MSAL) for Python.

  Blocking MSAL functions are executed in the executor thread.
  Should be useful until such time as MSAL Python gets a true async version.

  Tested with MSAL Python 1.21.0 onward - [MSAL Python docs](https://github.com/AzureAD/microsoft-authentication-library-for-python)



  The AsyncMSAL class wraps the behavior in the following example app
  <https://github.com/Azure-Samples/ms-identity-python-webapp/blob/master/app.py#L76>

  It is responsible to manage tokens & token refreshes and as a client to retrieve data using these tokens.



  Firstly you should get the tokens via OAuth

  1. `initiate_auth_code_flow` [referernce](https://msal-python.readthedocs.io/en/latest/#msal.PublicClientApplication.initiate_auth_code_flow)

      The caller is expected to:
      1. somehow store this content, typically inside the current session of the server,
      2. guide the end user (i.e. resource owner) to visit that auth_uri, typically with a redirect
      3. and then relay this dict and subsequent auth response to
          acquire_token_by_auth_code_flow().

      **Step 1** and part of **Step 3** is stored by this class in the aiohttp_session

  2. `acquire_token_by_auth_code_flow` [referernce](https://msal-python.readthedocs.io/en/latest/#msal.PublicClientApplication.initiate_auth_code_flow)



  Now you are free to make requests (typically from an aiohttp server)

  ```python
  session = await get_session(request)
  aiomsal = AsyncMSAL(session)
  async with aiomsal.get("https://graph.microsoft.com/v1.0/me") as res:
      res = await res.json()
  ```



  Complete routes can be found in [routes.py](./aiohttp_msal/routes.py)



  ```python
  @ROUTES.get("/user/login")
  async def user_login(request: web.Request) -> web.Response:
      """Redirect to MS login page."""
      session = await new_session(request)

      redir = AsyncMSAL(session).build_auth_code_flow(
          redirect_uri=get_route(request, URI_USER_AUTHORIZED)
      )

      return web.HTTPFound(redir)
  ```



  ```python
  @ROUTES.post(URI_USER_AUTHORIZED)
  async def user_authorized(request: web.Request) -> web.Response:
      """Complete the auth code flow."""
      session = await get_session(request)
      auth_response = dict(await request.post())

      aiomsal = AsyncMSAL(session)
      await aiomsal.async_acquire_token_by_auth_code_flow(auth_response)
  ```



  - `@ROUTES.get("/user/photo")`

    Serve the user's photo from their Microsoft profile

  - `get_user_info`

    Get the user's email and display name from MS Graph

  - `get_manager_info`

    Get the user's manager info from MS Graph



  ```python
  from aiohttp_msal import ENV, AsyncMSAL
  from aiohttp_msal.redis_tools import get_session

  def main()
      
      
      ases = asyncio.run(get_session(MYEMAIL))
      client = GraphClient(ases.get_token)
      
      
  ```


pkgId: 1ea362edd95280703cbe48b3c8916af4abcf3e2b27aa7605c1a17fa1934ad921
name: python-aiohttp-oauth2-client
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: OAuth2 support for aiohttp client
url: https://github.com/VITObelgium/aiohttp-oauth2-client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-oauth2-client-1.0.2-1.src.rpm
checksum_type: sha256
description:
  This package adds support for OAuth 2.0 authorization to the `ClientSession` class of
  the [`aiohttp`](https://docs.aiohttp.org/en/stable/) library.
  It handles retrieving access tokens and injects them in the Authorization header of HTTP requests as a Bearer token.

  **Features**:

  * Ease of use
  * Supported OAuth2 grants:
      * [Resource Owner Password Credentials](https://datatracker.ietf.org/doc/html/rfc6749#section-4.3)
      * [Client Credentials](https://datatracker.ietf.org/doc/html/rfc6749#section-4.4)
      * [Authorization Code (+ PKCE)](https://datatracker.ietf.org/doc/html/rfc6749#section-4.1)
      * [Device Code (+ PKCE)](https://datatracker.ietf.org/doc/html/rfc8628)
  * Automatic (lazy) refresh of tokens
  * Extensible code architecture



  The pacakge is available on [PyPi](https://pypi.org/project/aiohttp-oauth2-client) and can be installed using `pip`:

  ```shell
  pip install aiohttp-oauth2-client
  ```



  Begin by importing the relevant modules, like the OAuth2 client and grant. Also import `asyncio` for running async code:

  ```python
  import asyncio
  from aiohttp_oauth2_client.client import OAuth2Client
  from aiohttp_oauth2_client.grant.device_code import DeviceCodeGrant
  ```

  Then create an `OAuth2Grant` and `OAuth2Client` object and perform a HTTP request to a protected resource. We use the
  Device Code grant in this example:

  ```python
  async def main():
      async with DeviceCodeGrant(
              token_url=TOKEN_URL,
              device_authorization_url=DEVICE_AUTHORIZATION_URL,
              client_id=CLIENT_ID,
              pkce=True
      ) as grant, OAuth2Client(grant) as client:
          async with client.get(PROTECTED_ENDPOINT) as response:
              assert response.ok
              print(await response.text())


  asyncio.run(main())
  ```

  The client and grant objects can be used as async context managers. This ensures the proper setup and cleanup of
  associated resources.



  This section provides an overview of the configuration options for each grant type.
  Extra parameters can be provided, which will then be used in the authorization process.



  The authorization code grant uses a web browser login to request an authorization code, which is then used to request an
  access token.



  | Parameter           | Required | Description                 |
  |---------------------|----------|-----------------------------|
  | `token_url`         | Yes      | OAuth 2.0 Token URL         |
  | `authorization_url` | Yes      | OAuth 2.0 Authorization URL |
  | `client_id`         | Yes      | client identifier           |
  | `token`             | No       | OAuth 2.0 Token             |
  | `pkce`              | No       | use PKCE                    |



  ```python
  from aiohttp_oauth2_client.client import OAuth2Client
  from aiohttp_oauth2_client.grant.authorization_code import AuthorizationCodeGrant

  ...

  async with AuthorizationCodeGrant(
          token_url="https://sso.example.com/oauth2/token",
          authorization_url="https://sso.example.com/oauth2/auth",
          client_id="public",
          pkce=True
  ) as grant, OAuth2Client(grant) as client:
      ...
  ```



  Use client credentials to obtain an access token.



  | Parameter       | Required | Description         |
  |-----------------|----------|---------------------|
  | `token_url`     | Yes      | OAuth 2.0 Token URL |
  | `client_id`     | Yes      | client identifier   |
  | `client_secret` | Yes      | client secret       |
  | `token`         | No       | OAuth 2.0 token     |



  ```python
  from aiohttp_oauth2_client.client import OAuth2Client
  from aiohttp_oauth2_client.grant.client_credentials import ClientCredentialsGrant

  ...

  async with ClientCredentialsGrant(
          token_url="https://sso.example.com/oauth2/token",
          client_id="my-client",
          client_secret="top-secret"
  ) as grant, OAuth2Client(grant) as client:
      ...
  ```



  Obtain user authorization on devices with limited input capabilities or lack a suitable browser to handle an interactive
  log in procedure.
  The user is instructed to review the authorization request on a secondary device, which does have the requisite input
  and browser capabilities to complete the user interaction.



  | Parameter                  | Required | Description                        |
  |----------------------------|----------|------------------------------------|
  | `token_url`                | Yes      | OAuth 2.0 Token URL                |
  | `device_authorization_url` | Yes      | OAuth 2.0 Device Authorization URL |
  | `client_id`                | Yes      | client identifier                  |
  | `token`                    | No       | OAuth 2.0 Token                    |
  | `pkce`                     | No       | use PKCE                           |



  ```python
  from aiohttp_oauth2_client.client import OAuth2Client
  from aiohttp_oauth2_client.grant.device_code import DeviceCodeGrant

  ...

  async with DeviceCodeGrant(
          token_url="https://sso.example.com/oauth2/token",
          device_authorization_url="https://sso.example.com/oauth2/auth/device",
          client_id="public",
          pkce=True
  ) as grant, OAuth2Client(grant) as client:
      ...
  ```



  Use the username and password of the resource owner to obtain an access token.



  | Parameter   | Required | Description                    |
  |-------------|----------|--------------------------------|
  | `token_url` | Yes      | OAuth 2.0 Token URL            |
  | `username`  | Yes      | username of the resource owner |
  | `password`  | Yes      | password of the resource owner |
  | `token`     | No       | OAuth 2.0 Token                |



  ```python
  from aiohttp_oauth2_client.client import OAuth2Client
  from aiohttp_oauth2_client.grant.resource_owner_password_credentials import ResourceOwnerPasswordCredentialsGrant

  ...

  async with ResourceOwnerPasswordCredentialsGrant(
          token_url="https://sso.example.com/oauth2/token",
          username="username",
          password="password123",
          client_id="public"
  ) as grant, OAuth2Client(grant) as client:
      ...
  ```



  To start developing on this project, you should install all needed dependencies for running and testing the code:

  ```shell
  pip install -e .[dev]
  ```

  This will also install linting and formatting tools, which can be automatically executed when you commit using Git.
  To set up pre-commit as a Git hook, run:

  ```shell
  pre-commit install
  ```

  You can also run the pre-commit checks manually with the following command:

  ```shell
  pre-commit run --all-files
  ```



  This repository uses Sphinx to generate documentation for the Python package.
  To build the documentation, first install the required dependencies via the extra `docs`:

  ```shell
  pip install -e .[docs]
  ```

  Then go to the documentation directory and build the docs:

  ```shell
  cd docs/
  make html
  ```


pkgId: 4e87a1aed151941da6065384287483d7a89097d2624e4d1eb8c5e105cb0c5d95
name: python-aiohttp-openmetrics
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: OpenMetrics provider for aiohttp
url: https://github.com/jelmer/aiohttp-openmetrics/
rpm_license: Apache v2 or later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-openmetrics-0.0.12-1.src.rpm
checksum_type: sha256
description:
  This project contains a simple middleware and /metrics route endpoint for
  aiohttp that allow easy implementation of the
  `openmetrics <https://www.openmetrics.io/>`_ protocol.
  At the moment, this package is a thin wrapper around the ``prometheus_client``
  package.


pkgId: c4c314b4d1b4d2872f9b935196205f0ae7eb623114fabc1c3cfff70b6672bc60
name: python-aiohttp-proxy
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Full-featured proxy connector for aiohttp
url: https://github.com/Skactor/aiohttp-proxy
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-proxy-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/Skactor/aiohttp-proxy.svg?branch=master)](https://github.com/Skactor/aiohttp-proxy)
  [![Coverage Status](https://coveralls.io/repos/github/Skactor/aiohttp-proxy/badge.svg?branch=master)](https://coveralls.io/Skactor/aiohttp-proxy?branch=master)
  [![PyPI version](https://badge.fury.io/py/aiohttp-proxy.svg)](https://badge.fury.io/py/aiohttp-proxy)

  SOCKS proxy connector for [aiohttp](https://github.com/aio-libs/aiohttp). HTTP, HTTPS, SOCKS4(a) and SOCKS5(h) proxies are supported.


  - Python >= 3.5.3
  - aiohttp >= 2.3.2  # including v3.x


  ```
  pip install aiohttp_proxy
  ```




  ```python
  import aiohttp
  from aiohttp_proxy import ProxyConnector, ProxyType


  async def fetch(url):
      connector = ProxyConnector.from_url('http://user:password@127.0.0.1:1080')
      
      
      
      
      
      
      
      
      
      async with aiohttp.ClientSession(connector=connector) as session:
          async with session.get(url) as response:
              return await response.text()
  ```



  ```python
  from aiohttp_proxy import open_connection

  async def fetch():
      reader, writer = await open_connection(
          socks_url='http://user:password@127.0.0.1:1080',
          host='check-host.net',
          port=80
      )
      request = (b"GET /ip HTTP/1.1\r\n"
                 b"Host: check-host.net\r\n"
                 b"Connection: close\r\n\r\n")

      writer.write(request)
      return await reader.read(-1)
  ```



  First must declare, our code is based on [aiohttp-socks](https://github.com/romis2012/aiohttp-socks), thank you very much for the hard work.

  But in order to more flexible support for multiple proxy methods (not just SOCKS proxy),
  we decided to fork [aiohttp-socks] (https://github.com/romis2012/aiohttp-socks), which is currently based on it.

  Combine with native aiohttp to provide HTTP/HTTPS proxy instead of writing troublesome discriminating code based on the type of proxy.


pkgId: 7da1ad27e70c1c806b86f7c39db362d87e41f36a5ab4c7a6bf40b531ccc40e04
name: python-aiohttp-ratelimiter
arch: src
version: 4.1.2
epoch: 0
release: 1
summary: A simple rate limiter for aiohttp.web
url: https://jgltechnologies.com/aiohttplimiter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-ratelimiter-4.1.2-1.src.rpm
checksum_type: sha256
description:
  <a href="https://jgltechnologies.com/discord">
  <img src="https://discord.com/api/guilds/844418702430175272/embed.png">
  </a>



  aiohttp-ratelimiter is a rate limiter for the aiohttp.web framework.
  This is a new library, and we are always looking for people to contribute. If you see something wrong with the code or want to add a feature, please create a pull request
  on <a href="https://jgltechnologies.com/aiohttplimiter">our github</a>.


  Install from git
  ```
  python -m pip install git+https://github.com/JGLTechnologies/aiohttp-ratelimiter
  ```

  Install from pypi
  ```
  python -m pip install aiohttp-ratelimiter
  // if redis is being used
  python -m pip install aiohttp-ratelimiter[redis]
  // if memcached is being used
  python -m pip install aiohttp-ratelimiter[memcached]
  ```

  <br>


  Example

  ```python
  from aiohttp import web
  from aiohttplimiter import default_keyfunc, Limiter
  from aiohttplimiter.redis_limiter import RedisLimiter
  from aiohttplimiter.memcached_limiter import MemcachedLimiter

  app = web.Application()
  routes = web.RouteTableDef()


  limiter = Limiter(keyfunc=default_keyfunc)

  limiter = RedisLimiter(keyfunc=default_keyfunc, uri="redis://localhost:6379")

  limiter = MemcachedLimiter(keyfunc=default_keyfunc, uri="memcached://localhost:11211")

  @routes.get("/")

  @limiter.limit("1/second")
  async def home(request):
      return web.Response(text="test")

  app.add_routes(routes)
  web.run_app(app)
  ```

  <br>

  You can exempt an IP from rate limiting using the exempt_ips kwarg.

  ```python
  from aiohttplimiter import Limiter, default_keyfunc
  from aiohttp import web

  app = web.Application()
  routes = web.RouteTableDef()



  limiter = Limiter(keyfunc=default_keyfunc, exempt_ips={"192.168.1.245"})

  @routes.get("/")
  @limiter.limit("3/5minutes")
  async def test(request):
      return web.Response(text="test")

  app.add_routes(routes)
  web.run_app(app)
  ```

  <br>

  You can create your own error handler by using the error_handler kwarg.

  ```python
  from aiohttplimiter import Allow, RateLimitExceeded, Limiter, default_keyfunc
  from aiohttp import web

  def handler(request: web.Request, exc: RateLimitExceeded):
      
      if some_condition:
          return Allow()
      return web.Response(text=f"Too many requests", status=429)

  limiter = Limiter(keyfunc=default_keyfunc, error_handler=handler)
  ```

  <br>

  If multiple paths use one handler like this:
  ```python
  @routes.get("/")
  @routes.get("/home")
  @limiter.limit("5/hour")
  def home(request):
      return web.Response(text="Hello")
  ```

  <br>

  Then they will have separate rate limits. To prevent this use the path_id kwarg.

  ```python
  @routes.get("/")
  @routes.get("/home")
  @limiter.limit("2/3days", path_id="home")
  def home(request):
      return web.Response(text="Hello")
  ```

  <br>

  Views Example

  ```python
  @routes.view("/")
  class Home(View):
      @limiter.limit("1/second")
      def get(self):
          return web.Response(text="hello")
  ```


pkgId: 9a94725cc4f98c8dc66d8061749f125fde18c42667c66fcbb2fe1a8074655d7c
name: python-aiohttp-requests
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: A thin wrapper for aiohttp client with Requests simplicity
url: https://github.com/maxzheng/aiohttp-requests
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-requests-0.2.4-1.src.rpm
checksum_type: sha256
description:
  Behold, the power of aiohttp_ client with `Requests <http://docs.python-requests.org/>`_ simplicity:
      import asyncio
      import aiohttp
      from aiohttp_requests import requests
      async def main():
          response = await requests.get('https://api.github.com', auth=aiohttp.BasicAuth('user', 'password'))
          text = await response.text()
          json = await response.json()
          return response, text, json
      r, text, json = asyncio.run(main())
      >>> r
      <ClientResponse(https://api.github.com/) [200 OK]>
      >>> r.status
      200
      >>> r.headers['Content-Type']
      'application/json; charset=utf-8'
      >>> r.get_encoding()
      'utf-8'
      >>> text
      '{"current_user_url":"https://api.github.com/user",...'
      >>> json
      {'current_user_url': 'https://api.github.com/user', ... }
  Plus built-in concurrency control to do multiple requests safely:
      async def main():
          
          responses = await requests.get(['https://api.github.com'] * 2, auth=aiohttp.BasicAuth('user', 'password'))
          print(responses)    # [<ClientResponse(https://...) [200 OK]>, , <ClientResponse(https://...) [200 OK]>]
          
          requests.max_concurrency = 100
      asyncio.run(main())
  The `requests` object is just proxying `get` and other HTTP verb methods to `aiohttp.ClientSession`_, which returns `aiohttp.ClientResponse`_. To do anything else, read the aiohttp_ doc.


pkgId: 799e20cf19d92a10d5a1d91ecd86c252c0ec9c769311bec7a1d4539f9fc1ff54
name: python-aiohttp-retry
arch: src
version: 2.8.3
epoch: 0
release: 1
summary: Simple retry client for aiohttp
url: https://github.com/inyutin/aiohttp_retry
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-retry-2.8.3-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/inyutin/aiohttp_retry/branch/master/graph/badge.svg?token=ZWGAXSF1SP)](https://codecov.io/gh/inyutin/aiohttp_retry)

  Python 3.7 or higher.

  **Install**: `pip install aiohttp-retry`.

  [!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/inyutin)



  - Everything between [2.7.0 - 2.8.3) is yanked.
  There is a bug with evaluate_response_callback, it led to infinite retries

  - 2.8.0 is incorrect and yanked.
  https://github.com/inyutin/aiohttp_retry/issues/79

  - Since 2.5.6 this is a new parameter in ```get_timeout``` func called "response".
  If you have defined your own ```RetryOptions```, you should add this param into it.
  Issue about this: https://github.com/inyutin/aiohttp_retry/issues/59


  ```python
  from aiohttp_retry import RetryClient, ExponentialRetry

  async def main():
      retry_options = ExponentialRetry(attempts=1)
      retry_client = RetryClient(raise_for_status=False, retry_options=retry_options)
      async with retry_client.get('https://ya.ru') as response:
          print(response.status)

      await retry_client.close()
  ```

  ```python
  from aiohttp import ClientSession
  from aiohttp_retry import RetryClient

  async def main():
      client_session = ClientSession()
      retry_client = RetryClient(client_session=client_session)
      async with retry_client.get('https://ya.ru') as response:
          print(response.status)

      await client_session.close()
  ```

  ```python
  from aiohttp_retry import RetryClient, RandomRetry

  async def main():
      retry_options = RandomRetry(attempts=1)
      retry_client = RetryClient(raise_for_status=False, retry_options=retry_options)

      response = await retry_client.get('/ping')
      print(response.status)

      await retry_client.close()
  ```

  ```python
  from aiohttp_retry import RetryClient

  async def main():
      async with RetryClient() as client:
          async with client.get('https://ya.ru') as response:
              print(response.status)
  ```

  You can change parameters between attempts by passing multiple requests params:
  ```python
  from aiohttp_retry import RetryClient, RequestParams, ExponentialRetry

  async def main():
      retry_client = RetryClient(raise_for_status=False)

      async with retry_client.requests(
          params_list=[
              RequestParams(
                  method='GET',
                  url='https://ya.ru',
              ),
              RequestParams(
                  method='GET',
                  url='https://ya.ru',
                  headers={'some_header': 'some_value'},
              ),
          ]
      ) as response:
          print(response.status)

      await retry_client.close()
  ```

  You can also add some logic, F.E. logging, on failures by using trace mechanic.
  ```python
  import logging
  import sys
  from types import SimpleNamespace

  from aiohttp import ClientSession, TraceConfig, TraceRequestStartParams

  from aiohttp_retry import RetryClient, ExponentialRetry


  handler = logging.StreamHandler(sys.stdout)
  logging.basicConfig(handlers=[handler])
  logger = logging.getLogger(__name__)
  retry_options = ExponentialRetry(attempts=2)


  async def on_request_start(
      session: ClientSession,
      trace_config_ctx: SimpleNamespace,
      params: TraceRequestStartParams,
  ) -> None:
      current_attempt = trace_config_ctx.trace_request_ctx['current_attempt']
      if retry_options.attempts <= current_attempt:
          logger.warning('Wow! We are in last attempt')


  async def main():
      trace_config = TraceConfig()
      trace_config.on_request_start.append(on_request_start)
      retry_client = RetryClient(retry_options=retry_options, trace_configs=[trace_config])

      response = await retry_client.get('https://httpstat.us/503', ssl=False)
      print(response.status)

      await retry_client.close()
  ```
  Look tests for more examples. \
  **Be aware: last request returns as it is.**
  **If the last request ended with exception, that this exception will be raised from RetryClient request**


  `RetryClient` takes the same arguments as ClientSession[[docs](https://docs.aiohttp.org/en/stable/client_reference.html)] \
  `RetryClient` has methods:
  - request
  - get
  - options
  - head
  - post
  - put
  - patch
  - put
  - delete

  They are same as for `ClientSession`, but take one possible additional argument:
  ```python
  class RetryOptionsBase:
      def __init__(
          self,
          attempts: int = 3,  # How many times we should retry
          statuses: Optional[Iterable[int]] = None,  # On which statuses we should retry
          exceptions: Optional[Iterable[Type[Exception]]] = None,  # On which exceptions we should retry
          retry_all_server_errors: bool = True,  # If should retry all 500 errors or not
          
          evaluate_response_callback: Optional[EvaluateResponseCallbackType] = None,
      ):
          ...

      @abc.abstractmethod
      def get_timeout(self, attempt: int, response: Optional[Response] = None) -> float:
          raise NotImplementedError

  ```
  You can specify `RetryOptions` both for `RetryClient` and it's methods.
  `RetryOptions` in methods override `RetryOptions` defined in `RetryClient` constructor.

  **Important**: by default all 5xx responses are retried + statuses you specified as ```statuses``` param
  If you will pass ```retry_all_server_errors=False``` than you can manually set what 5xx errors to retry.

  You can define your own timeouts logic or use:
  - ```ExponentialRetry``` with exponential backoff
  - ```RandomRetry``` for random backoff
  - ```ListRetry``` with backoff you predefine by list
  - ```FibonacciRetry``` with backoff that looks like fibonacci sequence
  - ```JitterRetry``` exponential retry with a bit of randomness

  **Important**: you can proceed server response as an parameter for calculating next timeout.
  However this response can be None, server didn't make a response or you have set up ```raise_for_status=True```
  Look here for an example: https://github.com/inyutin/aiohttp_retry/issues/59

  Additionally, you can specify ```evaluate_response_callback```. It receive a ```ClientResponse``` and decide to retry or not by returning a bool.
  It can be useful, if server API sometimes response with malformed data.


  `RetryClient` add *current attempt number* to `request_trace_ctx` (see examples,
  for more info see [aiohttp doc](https://docs.aiohttp.org/en/stable/client_advanced.html#aiohttp-client-tracing)).


  `RetryClient` also has a method called `requests`. This method should be used if you want to make requests with different params.
  ```python
  @dataclass
  class RequestParams:
      method: str
      url: _RAW_URL_TYPE
      trace_request_ctx: Optional[Dict[str, Any]] = None
      kwargs: Optional[Dict[str, Any]] = None
  ```

  ```python
  def requests(
      self,
      params_list: List[RequestParams],
      retry_options: Optional[RetryOptionsBase] = None,
      raise_for_status: Optional[bool] = None,
  ) -> _RequestContext:
  ```

  You can find an example of usage above or in tests.
  But basically `RequestParams` is a structure to define params for `ClientSession.request` func.
  `method`, `url`, `headers` `trace_request_ctx` defined outside kwargs, because they are popular.

  There is also an old way to change URL between retries by specifying ```url``` as list of urls. Example:
  ```python
  from aiohttp_retry import RetryClient

  retry_client = RetryClient()
  async with retry_client.get(url=['/internal_error', '/ping']) as response:
      text = await response.text()
      assert response.status == 200
      assert text == 'Ok!'

  await retry_client.close()
  ```

  In this example we request ```/interval_error```, fail and then successfully request ```/ping```.
  If you specify less urls than ```attempts``` number in ```RetryOptions```, ```RetryClient``` will request last url at last attempts.
  This means that in example above we would request ```/ping``` once again in case of failure.



  `aiohttp_retry` is a typed project. It should be fully compatablie with mypy.

  It also introduce one special type:
  ```
  ClientType = Union[ClientSession, RetryClient]
  ```

  This type can be imported by ```from aiohttp_retry.types import ClientType```


pkgId: 77de3e26bf6ace0258a13dc25bbde4cf3d1aa8399faa66f6ec2ab78463198774
name: python-aiohttp-s3-client
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: The simple module for putting and getting object from Amazon S3 compatible endpoints
url: https://github.com/aiokitchen/aiohttp-s3-client
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-s3-client-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - License](https://img.shields.io/pypi/l/aiohttp-s3-client)](https://pypi.org/project/aiohttp-s3-client) [![Wheel](https://img.shields.io/pypi/wheel/aiohttp-s3-client)](https://pypi.org/project/aiohttp-s3-client) [![Mypy](http://www.mypy-lang.org/static/mypy_badge.svg)]() [![PyPI](https://img.shields.io/pypi/v/aiohttp-s3-client)](https://pypi.org/project/aiohttp-s3-client) [![PyPI](https://img.shields.io/pypi/pyversions/aiohttp-s3-client)](https://pypi.org/project/aiohttp-s3-client) [![Coverage Status](https://coveralls.io/repos/github/mosquito/aiohttp-s3-client/badge.svg?branch=master)](https://coveralls.io/github/mosquito/aiohttp-s3-client?branch=master) ![tox](https://github.com/mosquito/aiohttp-s3-client/workflows/tox/badge.svg?branch=master)
  The simple module for putting and getting object from Amazon S3 compatible endpoints

  ```bash
  pip install aiohttp-s3-client
  ```

  ```python
  from http import HTTPStatus
  from aiohttp import ClientSession
  from aiohttp_s3_client import S3Client
  async with ClientSession(raise_for_status=True) as session:
      client = S3Client(
          url="http://s3-url",
          session=session,
          access_key_id="key-id",
          secret_access_key="hackme",
          region="us-east-1"
      )
      
      async with client.put("bucket/str", "hello, world") as resp:
          assert resp.status == HTTPStatus.OK
      
      async with await client.put("bucket/bytes", b"hello, world") as resp:
          assert resp.status == HTTPStatus.OK
      
      async def gen():
          yield b'some bytes'
      async with client.put("bucket/file", gen()) as resp:
          assert resp.status == HTTPStatus.OK
      
      async with client.put_file("bucket/file", "/path_to_file") as resp:
          assert resp.status == HTTPStatus.OK
      
      async with client.head("bucket/key") as resp:
          assert resp == HTTPStatus.OK
      
      async with client.get("bucket/key") as resp:
          data = await resp.read()
      
      url = client.presign_url("GET", "bucket/key", expires=60 * 60)
      
      async with client.delete("bucket/key") as resp:
          assert resp == HTTPStatus.NO_CONTENT
      
      async for result, prefixes in client.list_objects_v2("bucket/", prefix="prefix"):
          
          
          do_work(result, prefixes)
  ```
  Bucket may be specified as subdomain or in object name:
  ```python
  import aiohttp
  from aiohttp_s3_client import S3Client
  client = S3Client(url="http://bucket.your-s3-host",
                    session=aiohttp.ClientSession())
  async with client.put("key", gen()) as resp:
  client = S3Client(url="http://your-s3-host",
                    session=aiohttp.ClientSession())
  async with await client.put("bucket/key", gen()) as resp:
  client = S3Client(url="http://your-s3-host/bucket",
                    session=aiohttp.ClientSession())
  async with client.put("key", gen()) as resp:
  ```
  Auth may be specified with keywords or in URL:
  ```python
  import aiohttp
  from aiohttp_s3_client import S3Client
  client_credentials_as_kw = S3Client(
      url="http://your-s3-host",
      access_key_id="key_id",
      secret_access_key="access_key",
      session=aiohttp.ClientSession(),
  )
  client_credentials_in_url = S3Client(
      url="http://key_id:access_key@your-s3-host",
      session=aiohttp.ClientSession(),
  )
  ```

  By default `S3Client` trying to collect all available credentials from keyword
  arguments like `access_key_id=` and `secret_access_key=`, after that from the
  username and password from passed `url` argument, so the next step is environment
  variables parsing and the last source for collection is the config file.
  You can pass credentials explicitly using `aiohttp_s3_client.credentials`
  module.

  ```python
  import aiohttp
  from aiohttp_s3_client import S3Client
  from aiohttp_s3_client.credentials import StaticCredentials
  credentials = StaticCredentials(
      access_key_id='aaaa',
      secret_access_key='bbbb',
      region='us-east-1',
  )
  client = S3Client(
      url="http://your-s3-host",
      session=aiohttp.ClientSession(),
      credentials=credentials,
  )
  ```

  ```python
  import aiohttp
  from aiohttp_s3_client import S3Client
  from aiohttp_s3_client.credentials import URLCredentials
  url = "http://key@hack-me:your-s3-host"
  credentials = URLCredentials(url, region="us-east-1")
  client = S3Client(
      url="http://your-s3-host",
      session=aiohttp.ClientSession(),
      credentials=credentials,
  )
  ```

  ```python
  import aiohttp
  from aiohttp_s3_client import S3Client
  from aiohttp_s3_client.credentials import EnvironmentCredentials
  credentials = EnvironmentCredentials(region="us-east-1")
  client = S3Client(
      url="http://your-s3-host",
      session=aiohttp.ClientSession(),
      credentials=credentials,
  )
  ```

  Using user config file:
  ```python
  import aiohttp
  from aiohttp_s3_client import S3Client
  from aiohttp_s3_client.credentials import ConfigCredentials
  credentials = ConfigCredentials()   # Will be used ~/.aws/credentials config
  client = S3Client(
      url="http://your-s3-host",
      session=aiohttp.ClientSession(),
      credentials=credentials,
  )
  ```
  Using the custom config location:
  ```python
  import aiohttp
  from aiohttp_s3_client import S3Client
  from aiohttp_s3_client.credentials import ConfigCredentials
  credentials = ConfigCredentials("~/.my-custom-aws-credentials")
  client = S3Client(
      url="http://your-s3-host",
      session=aiohttp.ClientSession(),
      credentials=credentials,
  )
  ```

  This function collect all passed credentials instances and return a new one
  which contains all non-blank fields from passed instances. The first argument
  has more priority.
  ```python
  import aiohttp
  from aiohttp_s3_client import S3Client
  from aiohttp_s3_client.credentials import (
      ConfigCredentials, EnvironmentCredentials, merge_credentials
  )
  credentials = merge_credentials(
      EnvironmentCredentials(),
      ConfigCredentials(),
  )
  client = S3Client(
      url="http://your-s3-host",
      session=aiohttp.ClientSession(),
      credentials=credentials,
  )
  ```

  Trying to get credentials from the metadata service:
  ```python
  import aiohttp
  from aiohttp_s3_client import S3Client
  from aiohttp_s3_client.credentials import MetadataCredentials
  credentials = MetadataCredentials()

  await credentials.start()
  client = S3Client(
      url="http://your-s3-host",
      session=aiohttp.ClientSession(),
  )
  await credentials.stop()
  ```

  For uploading large files [multipart uploading](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html)
  can be used. It allows you to asynchronously upload multiple parts of a file
  to S3.
  S3Client handles retries of part uploads and calculates part hash for integrity checks.
  ```python
  import aiohttp
  from aiohttp_s3_client import S3Client
  client = S3Client(url="http://your-s3-host", session=aiohttp.ClientSession())
  await client.put_file_multipart(
      "test/bigfile.csv",
      headers={
          "Content-Type": "text/csv",
      },
      workers_count=8,
  )
  ```

  S3 supports `GET` requests with `Range` header. It's possible to download
  objects in parallel with multiple connections for speedup.
  S3Client handles retries of partial requests and makes sure that file won't
  be changed during download with `ETag` header.
  If your system supports `pwrite` syscall (Linux, macOS, etc.) it will be used to
  write simultaneously to a single file. Otherwise, each worker will have own file
  which will be concatenated after downloading.
  ```python
  import aiohttp
  from aiohttp_s3_client import S3Client
  client = S3Client(url="http://your-s3-host", session=aiohttp.ClientSession())
  await client.get_file_parallel(
      "dump/bigfile.csv",
      "/home/user/bigfile.csv",
      workers_count=8,
  )
  ```


pkgId: 93f23a0badf35f629ab5a0d9f31f84154e637b848c15ebe377fb50fe4ad63618
name: python-aiohttp-socks
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Proxy connector for aiohttp
url: https://github.com/romis2012/aiohttp-socks
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-socks-0.9.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/romis2012/aiohttp-socks/actions/workflows/ci.yml/badge.svg)](https://github.com/romis2012/aiohttp-socks/actions/workflows/ci.yml)
  [![Coverage Status](https://codecov.io/gh/romis2012/aiohttp-socks/branch/master/graph/badge.svg)](https://codecov.io/gh/romis2012/aiohttp-socks)
  [![PyPI version](https://badge.fury.io/py/aiohttp-socks.svg)](https://pypi.python.org/pypi/aiohttp-socks)
  <!--
  [![Downloads](https://pepy.tech/badge/aiohttp-socks/month)](https://pepy.tech/project/aiohttp-socks)
  -->
  The `aiohttp-socks` package provides a proxy connector for [aiohttp](https://github.com/aio-libs/aiohttp).
  Supports SOCKS4(a), SOCKS5(h), HTTP (tunneling) as well as Proxy chains.
  It uses [python-socks](https://github.com/romis2012/python-socks) for core proxy functionality.



  - Python >= 3.6
  - aiohttp >= 2.3.2
  - python-socks[asyncio] >= 1.0.1


  ```
  pip install aiohttp_socks
  ```




  ```python
  import aiohttp
  from aiohttp_socks import ProxyType, ProxyConnector, ChainProxyConnector


  async def fetch(url):
      connector = ProxyConnector.from_url('socks5://user:password@127.0.0.1:1080')

      
      
      
      
      
      
      
      
      

      
      
      
      
      
      
      async with aiohttp.ClientSession(connector=connector) as session:
          async with session.get(url) as response:
              return await response.text()
  ```



  ```python
  from aiohttp_socks import open_connection

  async def fetch():
      reader, writer = await open_connection(
          proxy_url='socks5://user:password@127.0.0.1:1080',
          host='check-host.net',
          port=80
      )
      request = (b"GET /ip HTTP/1.1\r\n"
                 b"Host: check-host.net\r\n"
                 b"Connection: close\r\n\r\n")

      writer.write(request)
      return await reader.read(-1)
  ```



  Unlike [aiosocksy](https://github.com/romis2012/aiosocksy), aiohttp_socks has only single point of integration with aiohttp.
  This makes it easier to maintain compatibility with new aiohttp versions.


pkgId: 107420843bf9a3b5df76dc9162df9cfaf13ac4f85a0c7aea7b7249e2292cbfe8
name: python-aiohttp-socks
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Proxy connector for aiohttp
url: https://pypi.org/project/aiohttp-socks/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-socks-0.9.1-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/romis2012/aiohttp-socks/actions/workflows/ci.yml/badge.svg)](https://github.com/romis2012/aiohttp-socks/actions/workflows/ci.yml)
  [![Coverage Status](https://codecov.io/gh/romis2012/aiohttp-socks/branch/master/graph/badge.svg)](https://codecov.io/gh/romis2012/aiohttp-socks)
  [![PyPI version](https://badge.fury.io/py/aiohttp-socks.svg)](https://pypi.python.org/pypi/aiohttp-socks)
  <!--
  [![Downloads](https://pepy.tech/badge/aiohttp-socks/month)](https://pepy.tech/project/aiohttp-socks)
  -->
  The `aiohttp-socks` package provides a proxy connector for [aiohttp](https://github.com/aio-libs/aiohttp).
  Supports SOCKS4(a), SOCKS5(h), HTTP (tunneling) as well as Proxy chains.
  It uses [python-socks](https://github.com/romis2012/python-socks) for core proxy functionality.



  - Python >= 3.8
  - aiohttp >= 3.10.0
  - python-socks[asyncio] >= 1.0.1


  ```
  pip install aiohttp_socks
  ```




  ```python
  import aiohttp
  from aiohttp_socks import ProxyType, ProxyConnector, ChainProxyConnector


  async def fetch(url):
      connector = ProxyConnector.from_url('socks5://user:password@127.0.0.1:1080')

      
      
      
      
      
      
      
      
      

      
      
      
      
      
      
      async with aiohttp.ClientSession(connector=connector) as session:
          async with session.get(url) as response:
              return await response.text()
  ```



  ```python
  from aiohttp_socks import open_connection

  async def fetch():
      reader, writer = await open_connection(
          proxy_url='socks5://user:password@127.0.0.1:1080',
          host='check-host.net',
          port=80
      )
      request = (b"GET /ip HTTP/1.1\r\n"
                 b"Host: check-host.net\r\n"
                 b"Connection: close\r\n\r\n")

      writer.write(request)
      return await reader.read(-1)
  ```



  Unlike [aiosocksy](https://github.com/romis2012/aiosocksy), aiohttp_socks has only single point of integration with aiohttp.
  This makes it easier to maintain compatibility with new aiohttp versions.


pkgId: 97a43dbaca14d8a061b52a6fa8048084fb8f9bf7e39cd94b54154f0e443bee60
name: python-aiohttp-sse
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Server-sent events support for aiohttp.
url: https://github.com/aio-libs/aiohttp_sse/
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-sse-2.2.0-1.src.rpm
checksum_type: sha256
description:
  The **EventSource** interface is used to receive server-sent events. It connects
  to a server over HTTP and receives events in text/event-stream format without
  closing the connection. *aiohttp-sse* provides support for server-sent
  events for aiohttp_.


pkgId: 89f50fe2ec59903593c432d5a23db220d74186d1c5d04e608906172ee53b368b
name: python-aiohttp-sse-client2
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A Server-Sent Event python client base on aiohttp
url: https://github.com/JelleZijlstra/aiohttp-sse-client2
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-sse-client2-0.3.0-1.src.rpm
checksum_type: sha256
description:
  * 0.3.0 (February 7, 2023)
    * Drop support for Python 3.6
    * Support Python 3.10 and 3.11
    * Include response body in exception for non-200 response codes


pkgId: 74975092203b8c861980a21924711cd1e43b1f44c93cc69fc80d8a42da6d403e
name: python-aiohttp-swagger
arch: src
version: 1.0.16
epoch: 0
release: 1
summary: Swagger API Documentation builder for aiohttp server
url: https://github.com/cr0hn/aiohttp-swagger
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-swagger-1.0.16-1.src.rpm
checksum_type: sha256
description:
  **LOOCKING FOR MAINTAINERS**!!!!!
  ![Logo](doc/source/_static/logo.png)
  [![Build Status](https://travis-ci.org/cr0hn/aiohttp-swagger.svg?branch=master)](https://travis-ci.org/cr0hn/aiohttp-swagger)
  [![codecov.io](https://codecov.io/github/cr0hn/aiohttp-swagger/coverage.svg?branch=master)](https://codecov.io/github/cr0hn/aiohttp-swagger)
  *aiohttp-swagger: Swagger API Documentation builder for aiohttp server*


pkgId: f81b712b0f9cfcd928911ca7bfabdccbf838fc9c0688fdff4094dad78e08d609
name: python-aiohttp-tokenauth
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Simple way to add token auth level in your aiohttp app
url: https://github.com/madnesspie/aiohttp-tokenauth
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp-tokenauth-0.0.2-1.src.rpm
checksum_type: sha256
description:
  (Press CTRL+C to quit)
  ```
  Now try to get access to url with token in "Authorization" header.
  ```bash
  $ curl -H 'Authorization: Bearer fake-token' http://0.0.0.0:8080
  {"uuid": "fake-uuid"}
  ```
  And result without token.
  ```bash
  $ curl http://0.0.0.0:8080
  401: Missing authorization header
  ```

  You can ignore specific routes, app the paths to "exclude_routes".
  ```python
  app = web.Application(middlewares=[
      token_auth_middleware(
          user_loader=user_loader,
          
          exclude_routes=('/exclude', r'/exclude/\w+/info'),
          exclude_methods=('POST',),
      ),
  ])
  ```

  For changing the scheme (prefix in "Authorization" header) use `auth_scheme` argument.
  ```python
  app = web.Application(middlewares=[
      token_auth_middleware(
          user_loader=user_loader,
          auth_scheme='Token',
      ),
  ])
  ```
  Now such request is valid:
  ```bash
  $ curl -H 'Authorization: Token fake-token' http://0.0.0.0:8080
  {"uuid": "fake-uuid"}
  ```


pkgId: 5088ebaf79c92b21a05a242ee8a9a1b7d5280058126348582a423b5c224c179d
name: python-aiohttp_autoreload
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Makes aiohttp server autoreload on source code change
url: https://github.com/anti1869/aiohttp_autoreload
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttp_autoreload-0.0.1-1.src.rpm
checksum_type: sha256
description:
  Makes aiohttp server autoreload on source code change.
  It's very first, heavily untested version that should be used only in development.
  Code is taken from tornado.autoreload module.
  call_periodic module is taken from akaIDIOT's gist https://gist.github.com/akaIDIOT/48c2474bd606cd2422ca


pkgId: 8f06ccde241f4529e6e5fcdf9a530c80686a653f8c24af1bbac0616e6a2efada
name: python-aiohttpx
arch: src
version: 0.0.12
epoch: 0
release: 1
url: https://github.com/GrowthEngineAI/aiohttpx
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohttpx-0.0.12-1.src.rpm
checksum_type: sha256
summary:
  A Python Wrapper for httpx that combines the httpx.AsyncClient with the httpx.Client to allow both async and sync requests

description:
  ```bash

  pip install --upgrade aiohttpx

  pip install --upgrade git+https://github.com/trisongz/aiohttpx


pkgId: b024c44355094a2015bfe43e3f4d753351c20c7f22b9223af05786164e56daf0
name: python-aiohue
arch: src
version: 4.7.3
epoch: 0
release: 1
summary: Python module to talk to Philips Hue.
url: https://pypi.org/project/aiohue/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohue-4.7.3-1.src.rpm
checksum_type: sha256
description:
  Requires Python 3.10+ and uses asyncio and aiohttp.

  For usage examples, see the examples folder.



  This library supports both the new style V2 API (only available on V2 bridges) and the old style V1 API.
  The biggest advantage of the V2 API is that it supports event based updates so polling is not required.



  Object hierarchy and property/method names should match the Philips Hue API.


pkgId: cb66c84bd7934b51b15f94b8faea03b8ed1285bfc1e94045fab35b56cc6a8220
name: python-aiohuesyncbox
arch: src
version: 0.0.30
epoch: 0
release: 1
summary: Asyncio package to communicate with a Philips Hue Play HDMI Sync Box.
url: https://github.com/mvdwetering/aiohuesyncbox
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohuesyncbox-0.0.30-1.src.rpm
checksum_type: sha256
description:
  Asyncio package to communicate with Philips Hue Play HDMI Sync Box.
  This package is aimed at basic control of the box. Initial setup and configuration is assumed to done with the official Hue app.




  ```bash
      python3 -m pip install aiohuesyncbox
  ```



  Instantiate the HueSyncBox class and access the API.

  For more details on the API see the official API documentation on https://developers.meethue.com



  Changing a bridge is a bit more involved than other calls.
  After calling `box.hue.set_bridge()` the syncbox will start switching which takes a while (seems to take about 15 seconds).
  You will have to wait until the attributes match the expected endstate, but the status displayed on the API can be a bit confusing during the process.

  These are the status changes I see when switching from bridge A to bridge B.

  * ID: Bridge A, IP: Bridge A, Status: connected
  * Call `box.hue.set_bridge()` with info for bridge B
  * ID: Bridge B, IP: Bridge A, Status: connecting
  * ID: Bridge B, IP: Bridge B, Status: disconnected
  * ID: Bridge B, IP: Bridge B, Status: connected or ID: Bridge B, IP: Bridge B, Status: invalidgroup




  The examples below are available as a runnable script in the repository.
  There is also an example on using `zeroconf` for device discovery.



  ```python
      from aiohuesyncbox import HueSyncBox, InvalidState

      
      
      
      box = HueSyncBox(host, id)

      print("Press the button on the box for a few seconds until the light blinks green.")

      registration_info = None
      while not registration_info:
          try:
              registration_info = await box.register("Your application", "Your device")
          except InvalidState:
              
              pass
          await asyncio.sleep(1)

      
      print(registration_info)

      
      
      await box.unregister(registration_info['registration_id'])
  ```



  ```python

      from aiohuesyncbox import HueSyncBox

      
      
      box = HueSyncBox(host, id, access_token_from_registration_info)

      
      await box.initialize()
      print(box.device.name)
      print(box.execution.sync_active)
      print(box.execution.mode)

      
      await box.execution.set_state(sync_active=True, mode="video", hdmi_source="input4")

      
      await box.execution.update()
      print(box.execution.sync_active)
      print(box.execution.mode)
  ```


pkgId: f113e82042cc6ee3520a5ac8328c20b975d0137840994e9b51af5c93e7f40a36
name: python-aiohwenergy
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Python module to talk to HomeWizard Energy Devices.
url: https://github.com/DCSBL/aiohwenergy
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiohwenergy-0.8.0-1.src.rpm
checksum_type: sha256
description:
  Asyncio package to communicate with HomeWizard Energy devices
  This package is aimed at basic control of the device. Initial setup and configuration is assumed to done with the official HomeWizard Energy app.



  This package is not developed, nor supported by HomeWizard.


  ```bash
  python3 -m pip install aiohwenergy
  ```


  Instantiate the HWEnergy class and access the API.

  For more details on the API see the official API documentation on
  https://homewizard-energy-api.readthedocs.io


  The example below is available as a runnable script in the repository.

  ```python
  from aiohwenergy import HomeWizardEnergy

  device = HomeWizardEnergy(args.host)


  await device.update()


  print(device.device.product_name)
  print(device.device.serial)
  print(device.data.wifi_ssid)


  await device.close()
  ```


pkgId: da210a026e982df3ae512fca613e0ab1f69ea7c23c7b64eb6a0323f93febefe7
name: python-aioinflux
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Asynchronous Python client for InfluxDB
url: https://github.com/gusutabopb/aioinflux
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioinflux-0.9.0-1.src.rpm
checksum_type: sha256
description:
  Asynchronous Python client for `InfluxDB`_. Built on top of
  `aiohttp`_ and `asyncio`_.
  Aioinflux is an alternative to the official InfluxDB Python client.
  Aioinflux supports interacting with InfluxDB in a non-blocking way by using `aiohttp`_.
  It also supports writing and querying of `Pandas`_ dataframes,
  among other handy functionality.
  Please refer to the `documentation`_ for more details.


pkgId: efa400f45b78f19a88cf13ea07189c3cf77b631d712303c34cf12dc9efe1e9a9
name: python-aioinject
arch: src
version: 0.35.2
epoch: 0
release: 1
summary: Async dependency injection library
url: https://pypi.org/project/aioinject/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioinject-0.35.2-1.src.rpm
checksum_type: sha256
description:
  Async-first dependency injection library based on python type hints,
  see [documentation](https://thirvondukr.github.io/aioinject/)


  Install using pip `pip install aioinject`


pkgId: 44eae377bfca6484e11a1ed30ccb5875a671b32e0eadd8db73693a6be5946e90
name: python-aioinstagrapi
arch: src
version: 1.1.16
epoch: 0
release: 1
summary: Fast and effective asynchronous Instagram Private API wrapper
url: https://github.com/ragedotdev/aioinstagrapi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioinstagrapi-1.1.16-1.src.rpm
checksum_type: sha256
description:
  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 around https://githib.com/adw0rd/instagrapi

  Features:

  1. Performs Public API (web, anonymous) or Private API (mobile app, authorized)
     requests depending on the situation (to avoid Instagram limits)
  2. Challenge Resolver have Email (as well as recipes for automating receive a code from email) and SMS handlers
  3. Support upload a Photo, Video, IGTV, Clips (Reels), Albums and Stories
  4. Support work with User, Media, Insights, Collections, Location (Place), Hashtag and Direct objects
  5. Like, Follow, Edit account (Bio) and much more else
  6. Insights by account, posts and stories
  7. Build stories with custom background, font animation, swipe up link and mention users
  8. In the next release, account registration and captcha passing will appear


pkgId: 310fc369580cc16e1ab92cdd6f46998f26cfdcda7d9b4fa66ca555a66433fa26
name: python-aioiregul
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Asynchronous library to get data from IRegul systems
url: https://github.com/PoppyPop/aioiregul
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioiregul-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Requires Python 3 and uses asyncio, aiohttp and BeautifulSoup4.

  ```python
  import aioiregul
  import aiohttp
  import asyncio

  async def main():
      opt = aioiregul.ConnectionOptions(username='User', password='Pass')

      dev = aioiregul.Device(opt)

      res = await dev.collect()

      print(res)

  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())
  ```


pkgId: 7cd41cfd2a36d2e31c235e877e83c865a82cac1cd0a2156deac32f7e5ec37e69
name: python-aioitertools
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: itertools and builtins for AsyncIO and mixed iterables
url: https://pypi.org/project/aioitertools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioitertools-0.12.0-1.src.rpm
checksum_type: sha256
description:
  Implementation of itertools, builtins, and more for AsyncIO and mixed-type iterables.
  [![documentation](https://readthedocs.org/projects/aioitertools/badge/?version=latest)](https://aioitertools.omnilib.dev)
  [![version](https://img.shields.io/pypi/v/aioitertools.svg)](https://pypi.org/project/aioitertools)
  [![changelog](https://img.shields.io/badge/change-log-blue)](https://aioitertools.omnilib.dev/en/latest/changelog.html)
  [![license](https://img.shields.io/pypi/l/aioitertools.svg)](https://github.com/omnilib/aioitertools/blob/master/LICENSE)


pkgId: 58aa17d5f67c0a3f93ffc8f4bcb489b4448d97de1694149d2534804e17992c00
name: python-aiojellyfin
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: Async library for Jellyfin
url: https://pypi.org/project/aiojellyfin/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiojellyfin-0.10.1-1.src.rpm
checksum_type: sha256
description:
  Simple asyncio library for accessing Jellyfin.

  This library is meant to provide what is needed for Music Assistant. At this time it is *not* meant to be a thorough and complete Jellyfin wrapper.


pkgId: 619c1c7123e8ab1778ad70dfa13ed9ac2bfa55226fe6670ae159920b4e35ff5b
name: python-aiojenkins
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Asynchronous library of Jenkins API based on aiohttp
url: https://github.com/pbelskiy/aiojenkins
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiojenkins-0.8.0-1.src.rpm
checksum_type: sha256
description:
  |Build status|
  |Docs status|
  |Coverage status|
  |Version status|
  |Downloads status|
     image:: https://github.com/pbelskiy/aiojenkins/workflows/Tests/badge.svg
     image:: https://readthedocs.org/projects/aiojenkins/badge/?version=latest
     image:: https://img.shields.io/coveralls/github/pbelskiy/aiojenkins?label=Coverage
     image:: https://img.shields.io/pypi/pyversions/aiojenkins?label=Python
     image:: https://img.shields.io/pypi/dm/aiojenkins?color=1&label=Downloads


pkgId: b5b8d52cd06a97bf0362917552a7386099450b1ab8c4491c4604c2fac3439bf5
name: python-aiokatcp
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Asynchronous I/O implementation of the katcp protocol
url: https://github.com/ska-sa/aiokatcp
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiokatcp-2.0.1-1.src.rpm
checksum_type: sha256
description:
  aiokatcp is an implementation of the `katcp`_ protocol based around the Python
  asyncio system module. It requires Python 3.8 or later. It is loosely inspired
  by the `Python 2 bindings`_, but has a much narrower scope.
  The current implementation provides both client and server APIs. It only
  supports katcp version 5, and does not support a number of features that are
  marked deprecated in version 5.
  Full documentation can be found on `readthedocs`_.


pkgId: 266fdf832a7d86fb95b29794a89926f0b286084f6bc27467427a54e2eca2590f
name: python-aiokdb
arch: src
version: 0.1.16
epoch: 0
release: 1
summary: Pure Python asyncio connector to KDB
url: https://github.com/TeaEngineering/aiokdb
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiokdb-0.1.16-1.src.rpm
checksum_type: sha256
description:
  ![Python versions](https://img.shields.io/pypi/pyversions/aiokdb.svg) ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/TeaEngineering/aiokdb/check.yml) [![PyPI version](https://badge.fury.io/py/aiokdb.svg)](https://badge.fury.io/py/aiokdb)
  [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FTeaEngineering%2Faiokdb.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2FTeaEngineering%2Faiokdb?ref=badge_shield)


  Python asyncio connector to KDB. Pure python, so does not depend on the `k.h` bindings or kdb shared objects, or numpy/pandas. Fully type hinted to comply with `PEP-561`. No non-core dependencies, and tested on Python 3.8 - 3.12.



  [qPython](https://github.com/exxeleron/qPython) is a widely used library for this task and it maps objects to Pandas Dataframes which might be more suitable for the majority of applications.

  This library takes a different approach and aims to replicate using the KDB C-library functions, ie. being 100% explicit about KDB types. It was built working from the publicly documented [Serialisation Examples](https://code.kx.com/q/kb/serialization/) and [C API for kdb+](https://code.kx.com/q/wp/capi/) pages. Users might also need to be familiar with [k.h](https://github.com/KxSystems/ffi/blob/master/include/k.h).

  A simple example, using blocking sockets:

  ```python


  from aiokdb.socket import khpu

  h = khpu("localhost", 12345, "kdb:pass")


  result = h.k("2.0+3.0")

  assert result.aF() == 5.0

  result.aJ() # raises ValueError: wrong type KF (-9) for aJ
  ````

  The `result` object is a K-like Python object (a `KObj`), having the usual signed integer type available as `result.type`. Accessors for the primitive types are prefixed with an `a` and check at runtime that the accessor is appropriate for the stored type (`.aI()`, `.aJ()`, `.aH()`, `.aF()` etc.). Atoms store their value to a `bytes` object irrespective of the type, and encode/decode on demand. Atomic values can be set with (`.i(3)`, `.j(12)`, `.ss("hello")`).

  Arrays are implemented with subtypes that use [Python's native arrays module](https://docs.python.org/3/library/array.html) for efficient array types. The `MutableSequence` arrays are returned using the usual array accessor functions `.kI()`, `.kB()`, `.kS()` etc.

  Serialisation is handled by the `b9` function, which encodes a `KObj` to a python `bytes`, and the `d9` function which takes a `bytes` and returns a `KObj`.

  * Atoms are created by `ka`, `kb`, `ku`, `kg`, `kh`, `ki`, `kj`, `ke`, `kf`, `kc`, `ks`, `kt`, `kd`, `kz`, `ktj`
  * Lists with `ktn` and `knk`
  * Dictionaries with `xd` and tables with `xt`.

  Python manages garbage collection, so none of the reference counting primitives exist, i.e. `k.r` and functions `r1`, `r0` and `m9`, `setm`.



  Both kdb client and server *protocols* are implemented using asyncio, and can be tested back-to-back.
  For instance running `python -m aiokdb.server` and then `python -m aiokdb.client` will connect together using KDB IPC. However since there is no _interpreter_ (and the default server does not handle any commands) the server will return an `nyi` error to all queries. To implement a partial protocol for your own application, subclass `aiokdb.server.ServerContext` and implement `on_sync_request()`, `on_async_message()`, and perhaps `check_login()`.



  Usable command line client support for connecting to a remote KDB instance (using python `asyncio`, and `prompt_toolkit` for line editing and history) is built into the package:

  ```bash
  $ pip install aiokdb prompt_toolkit
  $ ./q -p 12345 &
  $ python -m aiokdb.cli --host localhost --port 12345
  (eval) > ([s:7 6 0Nj]x:3?0Ng;y:2)
  s| x                                    y
  -|---------------------------------------
  7| 409031f3-b19c-6770-ee84-6e9369c98697 2
  6| 52cb20d9-f12c-9963-2829-3c64d8d8cb14 2
   | cddeceef-9ee9-3847-9172-3e3d7ab39b26 2
  (eval) > 4 5 6!(`abc`def;til 300;(3 4!`a`b))
  4| abc def
  5| 0 1 2 ... 297 298 299
  6| KDict
  (eval) > [ctrl-D]
  $
  ```

  Text formatting above is controlled by `aiokdb.format.ASCIIFormatter`, which looks inside a `KObj` to render `XD`, `SD`, `XT` types in tabular form containing atom and vector values. Nested complex types ie. dictionary or table render as `KDict` or `KFlip` constant.


  Ordinary `.qdb` files written with set can be read by `kfromfile` or written by `ktofile`:

  ```python
  >>> from aiokdb.files import kfromfile, ktofile
  >>> k = kfromfile('test_qdb0/test.qdb')
  >>> k
  <aiokdb.KObjArray object at 0x7559136d8230>
  >>> from aiokdb.format import AsciiFormatter
  >>> fmt = AsciiFormatter()
  >>> print(fmt.format(k))
  [5, hello]
  ```

  Ordinarily `k` is dictionary representing a KDB namespace containing other objects.


  The library has extensive test coverage, however de-serialisation of certain (obscure) KObj may not be fully supported yet. PR's welcome. All tests are pure python except for those in `test/test_rpc.py`, which will use a real KDB server to test against if you set the `KDB_PYTEST_SERVICE` environment variable (to a URL of the form `kdb://user:password@hostname:port`), otherwise that test is skipped.

  * Formatting with `ruff check .`
  * Formatting with `ruff format .`
  * Check type annotations with `mypy --strict .`
  * Run `pytest .` in the root directory



  [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FTeaEngineering%2Faiokdb.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2FTeaEngineering%2Faiokdb?ref=badge_large)


pkgId: 02de7de181fe1af0b75111e4a9a7d9589843e6030079e278404812c755e324e6
name: python-aiokef
arch: src
version: 0.2.17
epoch: 0
release: 1
summary: Asyncio Python API for KEF speakers.
url: https://github.com/basnijholt/aiokef
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiokef-0.2.17-1.src.rpm
checksum_type: sha256
description:
  [![license](https://img.shields.io/github/license/basnijholt/aiokef)](https://github.com/basnijholt/aiokef/blob/master/LICENSE)
  [![tests](https://github.com/basnijholt/aiokef/workflows/tests/badge.svg)](https://github.com/basnijholt/aiokef/actions?query=workflow%3Atests)
  [![codecov](https://img.shields.io/codecov/c/github/basnijholt/aiokef)](https://codecov.io/gh/basnijholt/aiokef)
  [![docs](https://img.shields.io/readthedocs/aiokef)](https://aiokef.readthedocs.io)
  [![version](https://img.shields.io/pypi/v/aiokef)](https://pypi.org/project/aiokef/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aiokef)](https://pypi.org/project/aiokef/)

  Supported: *KEF LS50 Wireless* (tested with latest firmware of 19-11-2019: p6.3001902221.105039422 and older firmware: p6.2101809171.105039422)
  Untested: *KEF LSX*


  - Get and set volume
  - Mute and unmute
  - Get and set source input
  - Turn speaker on and off
  - Invert L/R to R/L
  - Play and pause (only works with Wifi and Bluetooth)
  - Previous and next track (only works with Wifi and Bluetooth)
  - Set the standby time to infinite, 20 minutes, or 60 minutes
  - Automatically connects and disconnects when speakers goes online/offline
  - Control **all** DSP settings!


  See [basnijholt/media_player.kef](https://github.com/basnijholt/media_player.kef/).


  ```bash
  pip install aiokef
  ```


  See this [Home Assistant discussion thread](https://community.home-assistant.io/t/kef-ls50-wireless/) where the creation of the KEF speakers is discussed.


  MIT License


  - Bas Nijholt
  - Robin Grönberg ([@Gronis](https://github.com/Gronis/pykef))
  - Bastian Beggel ([@bastianbeggel](https://github.com/bastianbeggel/hasskef))
  - chimpy ([@chimpy](https://github.com/chimpy))


pkgId: 52f4c2672c8dea6e4a10d4265814cd58cb16b498e6b429fa3c2607af716786ce
name: python-aiokeydb
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Python client for KeyDB database and key-value store
url: https://github.com/trisongz/aiokeydb-py
rpm_license: MIT Style
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiokeydb-0.2.1-1.src.rpm
checksum_type: sha256
description:
  `aiokeydb` can be installed from `pypi` using `pip` or from source.

  ```bash

  pip install aiokeydb

  pip install git+https://github.com/trisongz/aiokeydb-py.git
  ```

  Below are some examples of how to use `aiokeydb`. Additional examples can be found in the `tests` directory.
  ```python
  import time
  import asyncio
  import uuid
  from aiokeydb import KeyDBClient




  keydb_uri = "keydb://localhost:6379/0"

  KeyDBClient.init_session(
      uri = keydb_uri,
  )





  @KeyDBClient.cachify()
  async def async_fibonacci(number: int):
      if number == 0: return 0
      elif number == 1: return 1
      return await async_fibonacci(number - 1) + await async_fibonacci(number - 2)
  @KeyDBClient.cachify()
  def fibonacci(number: int):
      if number == 0: return 0
      elif number == 1: return 1
      return fibonacci(number - 1) + fibonacci(number - 2)
  async def test_fib(n: int = 100, runs: int = 10):
      
      sync_t, async_t = 0.0, 0.0
      for i in range(runs):
          t = time.time()
          print(f'[Async - {i}/{runs}] Fib Result: {await async_fibonacci(n)}')
          tt = time.time() - t
          print(f'[Async - {i}/{runs}] Fib Time: {tt:.2f}s')
          async_t += tt
          t = time.time()
          print(f'[Sync  - {i}/{runs}] Fib Result: {fibonacci(n)}')
          tt = time.time() - t
          print(f'[Sync  - {i}/{runs}] Fib Time: {tt:.2f}s')
          sync_t += tt
      print(f'[Async] Cache Average Time: {async_t / runs:.2f}s | Total Time: {async_t:.2f}s')
      print(f'[Sync ] Cache Average Time: {sync_t / runs:.2f}s | Total Time: {sync_t:.2f}s')
  async def test_setget(runs: int = 10):
      
      
      
      sync_t, async_t = 0.0, 0.0
      for i in range(runs):
          value = str(uuid.uuid4())
          key = f'async-test-{i}'
          t = time.time()
          await KeyDBClient.async_set(key, value)
          assert await KeyDBClient.async_get(key) == value
          tt = time.time() - t
          print(f'[Async - {i}/{runs}] Get/Set: {key} -> {value} = {tt:.2f}s')
          async_t += tt
          value = str(uuid.uuid4())
          key = f'sync-test-{i}'
          t = time.time()
          KeyDBClient.set(key, value)
          assert KeyDBClient.get(key) == value
          tt = time.time() - t
          print(f'[Sync  - {i}/{runs}] Get/Set: {key}  -> {value} = {tt:.2f}s')
          sync_t += tt
      print(f'[Async] GetSet Average Time: {async_t / runs:.2f}s | Total Time: {async_t:.2f}s')
      print(f'[Sync ] GetSet Average Time: {sync_t / runs:.2f}s | Total Time: {sync_t:.2f}s')
  async def run_tests(fib_n: int = 100, fib_runs: int = 10, setget_runs: int = 10):
      
      
      
      await KeyDBClient.async_wait_for_ready()
      
      await test_fib(n = fib_n, runs = fib_runs)
      await test_setget(runs = setget_runs)
      
      await KeyDBClient.async_set('async_test_0', 'test')
      assert await KeyDBClient.async_get('async_test_0') == 'test'
      KeyDBClient.set('sync_test_0', 'test')
      assert KeyDBClient.get('sync_test_0') == 'test'
      
      
      await KeyDBClient.session.async_set('async_test_1', 'test')
      assert await KeyDBClient.session.async_get('async_test_1') == 'test'
      KeyDBClient.session.set('sync_test_1', 'test')
      assert KeyDBClient.session.get('sync_test_1') == 'test'
      
      
      
      
      
      
      await KeyDBClient.async_keydb.set('async_test_2', b'test')
      assert await KeyDBClient.async_keydb.get('async_test_2') == b'test'
      KeyDBClient.keydb.set('sync_test_2', b'test')
      assert KeyDBClient.keydb.get('sync_test_2') == b'test'
      
      
      
      
      
      
      await KeyDBClient.aclose()
  asyncio.run(run_tests())
  ```
  Additionally, you can use the previous APIs that are expected to be present
  ```python
  from aiokeydb import KeyDB, AsyncKeyDB, from_url
  sync_client = KeyDB()
  async_client = AsyncKeyDB()

  sync_client = from_url('keydb://localhost:6379/0')
  async_client = from_url('keydb://localhost:6379/0', asyncio = True)
  ```

  The library is designed to be explict and not have any global state. However, you can set the global client settings by using the `KeyDBClient.configure` method. This is useful if you are using the `KeyDBClient` class directly, or if you are using the `KeyDBClient` class in a library that you are developing.
  For example, if you initialize a session with a specific `uri`, the global client settings will still inherit from the default settings.
  ```python
  from aiokeydb import KeyDBClient
  from lazyops.utils import logger
  keydb_uris = {
      'default': 'keydb://127.0.0.1:6379/0',
      'cache': 'keydb://localhost:6379/1',
      'public': 'redis://public.redis.db:6379/0',
  }
  sessions = {}

  for name, uri in keydb_uris.items():
      sessions[name] = KeyDBClient.init_session(
          name = name,
          uri = uri,
      )
      logger.info(f'Session {name}: uri: {sessions[name].uri}')


  sessions['test'] = KeyDBClient.init_session(
      name = 'test',
  )
  logger.info(f'Session test: uri: {sessions["test"].uri}')
  ```
  By configuring the global settings, any downstream sessions will inherit the global settings.
  ```python
  from aiokeydb import KeyDBClient
  from lazyops.utils import logger
  default_uri = 'keydb://public.host.com:6379/0'
  keydb_dbs = {
      'cache': {
          'db_id': 1,
      },
      'db': {
          'uri': 'keydb://127.0.0.1:6379/0',
      },
  }
  KeyDBClient.configure(
      url = default_uri,
      debug_enabled = True,
      queue_db = 1,
  )

  sessions = {}



  KeyDBClient.init_session()
  for name, config in keydb_dbs.items():
      sessions[name] = KeyDBClient.init_session(
          name = name,
          **config
      )
      logger.info(f'Session {name}: uri: {sessions[name].uri}')


pkgId: 13ab3a1d2062bea8360eeb8828edf36fb22c416c7a470e57fddcb142e3d032f7
name: python-aiokilogram
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Convenience tools and wrappers for aiogram
url: https://github.com/altvod/aiokilogram
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiokilogram-0.1.3-1.src.rpm
checksum_type: sha256
description:
  Convenience tools and wrappers for `aiogram`,
  the asynchronous Telegram Bot API framework.




  ```bash
  pip install aiokilogram
  ```






  The `aiokilogram` toolkit is centered around the notion of class-based
  command handlers. Basically this means that you can group several commands
  as methods in a class and assign them to message and callback patterns
  at class level.

  A simplistic bit will look something like this:

  ```python
  import asyncio
  import os
  from aiokilogram.bot import KiloBot
  from aiokilogram.settings import BaseGlobalSettings
  from aiokilogram.handler import CommandHandler
  from aiokilogram.registration import register_message_handler

  class TestCommandHandler(CommandHandler):
      @register_message_handler(commands={'hello'})
      async def test_handler(self, event) -> None:
          await self.send_text(user_id=event.from_user.id, text=f'This is a test reply')

  def run_bot():
      bot = KiloBot(
          global_settings=BaseGlobalSettings(tg_bot_token=os.environ['TG_BOT_TOKEN']),
          handler_classes=[TestCommandHandler],
      )
      asyncio.run(bot.run())

  if __name__ == '__main__':
      run_bot()
  ```

  For more info you can take a look at a [boilerplate bot with buttons](boilerplate/button.py)
  and [simple boilerplate bot](boilerplate/simple.py)

  Set the `TG_BOT_TOKEN` env variable to run them.




  The package also provides a simplified mechanism of using buttons and
  binding handlers to their callbacks.
  This is useful when you want your buttons to contain a combination of
  several parameters and don't want to implement their serialization,
  deserialization and callback bindings each time.

  The idea is simple.

  1. Define an action (a `CallbackAction` subclass) using a combination of fields:
  ```python
  from enum import Enum
  from aiokilogram.action import CallbackAction, StringActionField, EnumActionField

  class ActionType(Enum):
      show_recipe = 'show_recipe'
      like_recipe = 'like_recipe'

  class SingleRecipeAction(CallbackAction):
      action_type = EnumActionField(enum_cls=ActionType)
      recipe_title = StringActionField()
  ```

  2. Create a page containing action buttons:
  ```python
  from aiokilogram.page import ActionMessageButton, MessagePage, MessageBody, MessageKeyboard

  page = MessagePage(
      body=MessageBody(text='Main Recipe Menu'),
      keyboard=MessageKeyboard(buttons=[
          ActionMessageButton(
              text='Button Text',
              action=SingleRecipeAction(
                  action_type=ActionType.show_recipe,
                  recipe_title='Fantastic Menemen',
              ),
          ),
          
      ])
  )
  ```

  3. Send it as a response to some command in your handler class:
  ```python
      await self.send_message_page(user_id=event.from_user.id, page=page)
  ```

  4. Define and register a handler method for this action where you deserialize the
     action parameters and somehow use them in your logic:
  ```python
  class MyHandler(CommandHandler):
      @register_callback_query_handler(action=SingleRecipeAction)
      async def do_single_recipe_action(self, query: types.CallbackQuery) -> None:
          action = SingleRecipeAction.deserialize(query.data)
          if 'soup' in action.recipe_title.lower():
              do_soup_stuff()  # whatever
          
  ```
  or you can be more precise and limit the binding to specific values
  of the action's fields:
  ```python
      @register_callback_query_handler(
          action=SingleRecipeAction.when(action_type=ActionType.like_recipe),
      )
  ```


  See [boilerplate bot with buttons](boilerplate/button.py)

  Set the `TG_BOT_TOKEN` env variable to run it.




  Generic error (exception) handling in bots can be implemented via `ErrorHandler`s
  at class or method level.

  First, define an error handler:

  ```python
  from aiokilogram.errors import DefaultErrorHandler

  class MyErrorHandler(DefaultErrorHandler):
      def make_message(self, err: Exception):
          
          
          
          return 'This is my error message'
  ```

  Then add it either to the message handler class:

  ```python
  class MyCommandHandler(CommandHandler):
      error_handler = MyErrorHandler()
  ```

  to handle errors in all methods registered via the
  `register_message_handler` and `register_callback_query_handler` decorators.

  Or you can do it at method-level:

  ```python
      @register_message_handler(commands={'my_command'}, error_handler=MyErrorHandler())
      async def my_command_handler(self, event: types.Message) -> None:
          pass  # do whatever you do...
  ```

  See [boilerplate bot with error handling](boilerplate/errors.py)

  Set the `TG_BOT_TOKEN` env variable to run it.




  Homepage on GitHub: https://github.com/altvod/aiokilogram

  Project's page on PyPi: https://pypi.org/project/aiokilogram/

  `aiogram`'s homepage on GitHub: https://github.com/aiogram/aiogram

  Telegram Bot API: https://core.telegram.org/bots/api


pkgId: 258d3872663c00f8f368c1da87d0e013fdfc4ff77517e5e5229b403947a2245a
name: python-aiokwikset
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Python interface for Kwikset Smart Locks
url: https://github.com/explosivo22/aiokwikset
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiokwikset-0.2.1-1.src.rpm
checksum_type: sha256
description:
  Python library for communicating with the [Kwikset Smart Locks](https://www.kwikset.com/products/electronic/electronic-smart-locks) via the Kwikset cloud API.

  ***WARNING***
  * This library only works if you have signed up for and created a home/had a home shared with you from the Kwikset Application.
  * [IOS](https://apps.apple.com/us/app/kwikset/id1465996742)
  * [Android](https://play.google.com/store/apps/details?id=com.kwikset.blewifi)

  NOTE:

  * This library is community supported, please submit changes and improvements.
  * This is a very basic interface, not well thought out at this point, but works for the use cases that initially prompted spitting this out from.



  - locking/unlocking
  - retrieving basic information



  ```
  pip install aiokwikset
  ```



  ```python
  import asyncio

  from aiokwikset import API


  async def main() -> None:
      """Run!"""
      
      api = API("<EMAIL>")

      
      
      pre_auth = await api.authenticate('<PASSWORD>','<CODE_TYPE>')

      
      await api.verify_user(pre_auth, input("Code:"))

      
      user_info = await api.user.get_info()

      
      homes = await api.user.get_homes()

      
      devices = await api.device.get_devices(homes[0]['homeid'])

      
      device_info = await api.device.get_device_info(devices[0]['deviceid'])

      
      lock = await api.device.lock_device(device_info, user_info)

      
      led = await api.device.set_ledstatus(device_info, "false")

      
      audio = await api.device.set_audiostatus(device_info, "false")

      
      screen = await api.device.set_securescreenstatus(device_info, "false")


  asyncio.run(main())
  ```



  * not all APIs supported


pkgId: 7a4f224fca98ea2a4c5373d430df4da8a50c7ef6cb54b60eb0850496b0f73b98
name: python-aiolang
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Translate Google Framework For Python
url: https://pypi.org/project/aiolang/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiolang-0.0.1-1.src.rpm
checksum_type: sha256
description:
  ```python
  import asyncio
  from aiolang import Translate
  async def main():
      async with Translate() as translate:
          request = await translate.translate("Hello, World!", "KO")
          print(request)
  if __name__ == "__main__":
      asyncio.run(main())
  ```

  ```python
  import asyncio
  from aiolang import Translate
  async def main():
      translate = Translate()
      request = await translate("Hello, World!", "KO")
      print(request)
  if __name__ == "__main__":
      asyncio.run(main())


pkgId: c65c018fcf0ddf0b9f1222d2f836ec687d560eebbcc6f04bbd0debf56e48d14b
name: python-aioli-guestbook
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Comprehensive RESTful HTTP API built on top of the Aioli Framework
url: https://github.com/aioli-framework/aioli-guestbook-example
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioli-guestbook-0.3.3-1.src.rpm
checksum_type: sha256
description:
  The idea with this example is to show how a CRUD-type RESTful HTTP API package can be built with the Aioli Framework.


pkgId: 562eab5a57a094c3c917ee0391798cbfdd507aca3ab66617fd4a2ea6614132ce
name: python-aioli-sdk
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Aioli (AI OnLine Inference), a platform for deploying AI models at scale.
url: https://github.com/determined-ai/aioli
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioli-sdk-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Aioli (**AI** **O**n**L**ine **I**nference) is a platform for deploying models a
  t scale.

  See [https://docs.determined.ai/](https://docs.determined.ai/) for more information.


pkgId: c2b140055de6511742169ff9a06f555ef68c06783ee83e281a30aeb810b34092
name: python-aiolifx
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: API for local communication with LIFX devices over a LAN with asyncio.
url: http://github.com/aiolifx/aiolifx
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiolifx-1.1.1-1.src.rpm
checksum_type: sha256
description:
  aiolifx is a Python 3/asyncio library to control Lifx LED lightbulbs over your LAN.

  [![PyPI version fury.io](https://badge.fury.io/py/aiolifx.svg)](https://pypi.python.org/pypi/aiolifx)
  [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-licen)
  [![GITHUB-BADGE](https://github.com/aiolifx/aiolifx/workflows/black/badge.svg)](https://github.com/psf/black)
  [![Downloads](https://pepy.tech/badge/aiolifx/month)](https://pepy.tech/project/aiolifx)

  Most of it was taken from Meghan Clarkk lifxlan package (https://github.com/mclarkk)
  and adapted to Python 3 (and asyncio obviously)



  We are on PyPi so

       pip3 install aiolifx
  or
       python3 -m pip install aiolifx

  After installation, the utility

      aiolifx

  can be used to test/control devices.

  NOTE: When installing with Python 3.4, the installation produce an error message
        (syntax error). This can be safely ignored.




  Essentially, you create an object with at least 2 methods:

      - register
      - unregister

  You then start the LifxDiscovery task in asyncio. It will register any new light it finds.
  All the method communicating with the bulb can be passed a callback function to react to
  the bulb response. The callback should take 2 parameters:

      - a light object
      - the response message


  The easiest way is to look at the file in the examples directory. "Wifi" and "Uptime" use
  a callback to print the info when it is returned.


  In essence, the test program is this

      class bulbs():
      """ A simple class with a register and unregister methods
      """
          def __init__(self):
              self.bulbs=[]

          def register(self,bulb):
              self.bulbs.append(bulb)

          def unregister(self,bulb):
              idx=0
              for x in list([ y.mac_addr for y in self.bulbs]):
                  if x == bulb.mac_addr:
                      del(self.bulbs[idx])
                      break
                  idx+=1

      def readin():
      """Reading from stdin and displaying menu"""

          selection = sys.stdin.readline().strip("\n")
          DoSomething()

      MyBulbs = bulbs()
      loop = aio.get_event_loop()
      discovery = alix.LifxDiscovery(loop, MyBulbs)
      try:
          loop.add_reader(sys.stdin, readin)
          discovery.start()
          loop.run_forever()
      except:
          pass
      finally:
          discovery.cleanup()
          loop.remove_reader(sys.stdin)
          loop.close()


  Other things worth noting:

      -  Whilst LifxDiscovery uses UDP broadcast, the bulbs are
         connected with Unicast UDP

      - The socket connecting to a bulb is not closed unless the bulb is deemed to have
        gone the way of the Dodo. I've been using that for days with no problem

      - You can select to used IPv6 connection to the bulbs by passing an
        IPv6 prefix to LifxDiscovery. It's only been tried with /64 prefix.
        If you want to use a /48 prefix, add ":" (colon) at the end of the
        prefix and pray. (This means 2 colons at the end!)

      - I only have Original 1000, so I could not test with other types
        of bulbs

      - Unlike in lifxlan, set_waveform takes a dictionary with the right
        keys instead of all those parameters



  Run this command each time you make changes to the project. It enters at `__main__.py`

  ```bash
  pip3 install . && aiolifx
  ```



  Thanks to Anders Melchiorsen and Avi Miller for their essential contributions


pkgId: e91006347171936979848555f2dc93eef5c2c4b457f62d652cc58a0a0d040864
name: python-aiolimiter
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: asyncio rate limiter, a leaky bucket implementation
url: https://github.com/mjpieters/aiolimiter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiolimiter-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Azure Pipelines status for master branch][azure_badge]][azure_status]
  [![codecov.io status for master branch][codecov_badge]][codecov_status]
  [![Latest PyPI package version][pypi_badge]][aiolimiter_release]
  [![Latest Read The Docs][rtd_badge]][aiolimiter_docs]

  [azure_badge]: https://dev.azure.com/mjpieters/aiolimiter/_apis/build/status/CI?branchName=master
  [azure_status]: https://dev.azure.com/mjpieters/aiolimiter/_build/latest?definitionId=4&branchName=master "Azure Pipelines status for master branch"
  [codecov_badge]: https://codecov.io/gh/mjpieters/aiolimiter/branch/master/graph/badge.svg
  [codecov_status]: https://codecov.io/gh/mjpieters/aiolimiter "codecov.io status for master branch"
  [pypi_badge]: https://badge.fury.io/py/aiolimiter.svg
  [aiolimiter_release]: https://pypi.org/project/aiolimiter "Latest PyPI package version"
  [rtd_badge]: https://readthedocs.org/projects/aiolimiter/badge/?version=latest
  [aiolimiter_docs]: https://aiolimiter.readthedocs.io/en/latest/?badge=latest "Latest Read The Docs"



  An efficient implementation of a rate limiter for asyncio.

  This project implements the [Leaky bucket algorithm][], giving you precise control over the rate a code section can be entered:

  ```python
  from aiolimiter import AsyncLimiter


  rate_limit = AsyncLimiter(100, 30)


  async def some_coroutine():
      async with rate_limit:
          
          
          await do_something()
  ```

  It was first developed [as an answer on Stack Overflow][so45502319].



  https://aiolimiter.readthedocs.io



  ```sh
  $ pip install aiolimiter
  ```

  The library requires Python 3.7 or newer.



  - Python >= 3.7



  `aiolimiter` is offered under the [MIT license](./LICENSE.txt).



  The project is hosted on [GitHub][].

  Please file an issue in the [bug tracker][] if you have found a bug
  or have some suggestions to improve the library.



  This project uses [poetry][] to manage dependencies, testing and releases. Make sure you have installed that tool, then run the following command to get set up:

  ```sh
  poetry install --with docs && poetry run doit devsetup
  ```

  Apart from using `poetry run doit devsetup`, you can either use `poetry shell` to enter a shell environment with a virtualenv set up for you, or use `poetry run ...` to run commands within the virtualenv.

  Tests are run with `pytest` and `tox`. Releases are made with `poetry build` and `poetry publish`. Code quality is maintained with `flake8`, `black` and `mypy`, and `pre-commit` runs quick checks to maintain the standards set.

  A series of `doit` tasks are defined; run `poetry run doit list` (or `doit list` with `poetry shell` activated) to list them. The default action is to run a full linting, testing and building run. It is recommended you run this before creating a pull request.

  [leaky bucket algorithm]: https://en.wikipedia.org/wiki/Leaky_bucket
  [so45502319]: https://stackoverflow.com/a/45502319/100297
  [github]: https://github.com/mjpieters/aiolimiter
  [bug tracker]: https://github.com/mjpieters/aiolimiter/issues
  [poetry]: https://poetry.eustace.io/


pkgId: ac55f1a9b77f3b2a8ac8eba8f8c94078665c64038a446704a42eb997def7edeb
name: python-aiolimiter
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: asyncio rate limiter, a leaky bucket implementation
url: https://github.com/mjpieters/aiolimiter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiolimiter-1.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Azure Pipelines status for master branch][azure_badge]][azure_status]
  [![codecov.io status for master branch][codecov_badge]][codecov_status]
  [![Latest PyPI package version][pypi_badge]][aiolimiter_release]
  [![Latest Read The Docs][rtd_badge]][aiolimiter_docs]

  [azure_badge]: https://dev.azure.com/mjpieters/aiolimiter/_apis/build/status/CI?branchName=master
  [azure_status]: https://dev.azure.com/mjpieters/aiolimiter/_build/latest?definitionId=4&branchName=master "Azure Pipelines status for master branch"
  [codecov_badge]: https://codecov.io/gh/mjpieters/aiolimiter/branch/master/graph/badge.svg
  [codecov_status]: https://codecov.io/gh/mjpieters/aiolimiter "codecov.io status for master branch"
  [pypi_badge]: https://badge.fury.io/py/aiolimiter.svg
  [aiolimiter_release]: https://pypi.org/project/aiolimiter "Latest PyPI package version"
  [rtd_badge]: https://readthedocs.org/projects/aiolimiter/badge/?version=latest
  [aiolimiter_docs]: https://aiolimiter.readthedocs.io/en/latest/?badge=latest "Latest Read The Docs"



  An efficient implementation of a rate limiter for asyncio.

  This project implements the [Leaky bucket algorithm][], giving you precise control over the rate a code section can be entered:

  ```python
  from aiolimiter import AsyncLimiter


  rate_limit = AsyncLimiter(100, 30)


  async def some_coroutine():
      async with rate_limit:
          
          
          await do_something()
  ```

  It was first developed [as an answer on Stack Overflow][so45502319].



  https://aiolimiter.readthedocs.io



  ```sh
  $ pip install aiolimiter
  ```

  The library requires Python 3.8 or newer.



  - Python >= 3.8



  `aiolimiter` is offered under the [MIT license](./LICENSE.txt).



  The project is hosted on [GitHub][].

  Please file an issue in the [bug tracker][] if you have found a bug
  or have some suggestions to improve the library.



  This project uses [poetry][] to manage dependencies, testing and releases. Make sure you have installed that tool, then run the following command to get set up:

  ```sh
  poetry install --with docs && poetry run doit devsetup
  ```

  Apart from using `poetry run doit devsetup`, you can either use `poetry shell` to enter a shell environment with a virtualenv set up for you, or use `poetry run ...` to run commands within the virtualenv.

  Tests are run with `pytest` and `tox`. Releases are made with `poetry build` and `poetry publish`. Code quality is maintained with `flake8`, `black` and `mypy`, and `pre-commit` runs quick checks to maintain the standards set.

  A series of `doit` tasks are defined; run `poetry run doit list` (or `doit list` with `poetry shell` activated) to list them. The default action is to run a full linting, testing and building run. It is recommended you run this before creating a pull request.

  [leaky bucket algorithm]: https://en.wikipedia.org/wiki/Leaky_bucket
  [so45502319]: https://stackoverflow.com/a/45502319/100297
  [github]: https://github.com/mjpieters/aiolimiter
  [bug tracker]: https://github.com/mjpieters/aiolimiter/issues
  [poetry]: https://poetry.eustace.io/


pkgId: 18eba230c7aefac81065ccdf90f7acc148e5b12646d372ff7fa0c336a9e86f8a
name: python-aioload
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Load test tool
url: https://github.com/sonic182/aioload
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioload-0.4.0-1.src.rpm
checksum_type: sha256
description:
  https://blog.mogollon.com.ve/2020/01/10/load-testing-with-python/
  Load test tool using aiosonic_ http client. For drawing charts we
  use matplotlib and pandas.
  Usage of uvloop is highly recommended.


pkgId: 428bff86793b74154bd6fd21c18cd5f189a6b23232746919fbfd7c5c0f7e218e
name: python-aiologfields
arch: src
version: 2019.12.1
epoch: 0
release: 1
summary: aiologfields: inject Task-context-fields into loggers
url: https://github.com/cjrh/aiologfields
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiologfields-2019.12.1-1.src.rpm
checksum_type: sha256
description:
  ``aiologfields`` makes it easy to include **correlation IDs**, as well
  as other contextual information into log messages, across ``await``
  calls and ``loop.create_task()`` calls.  Correlation IDs are critically
  important for accurate telemetry in monitoring and debugging distributed
  microservices.


pkgId: 5b3bca8dfba55a212adb0db25d4b258413b211db815cd231508d8bc6b000642e
name: python-aiologger
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Asynchronous logging for python and asyncio
url: https://github.com/b2wdigital/aiologger
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiologger-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![PYPI](https://img.shields.io/pypi/v/aiologger.svg)](http://pypi.python.org/pypi/aiologger)
  [![PYPI Python Versions](https://img.shields.io/pypi/pyversions/aiologger.svg)](http://pypi.python.org/pypi/aiologger)
  [![Build Status](https://github.com/async-worker/aiologger/actions/workflows/main.yaml/badge.svg?branch=main)](https://github.com/async-worker/aiologger/actions/workflows/main.yaml)
  [![Maintainability](https://api.codeclimate.com/v1/badges/122a3696a749ed04a972/maintainability)](https://codeclimate.com/github/async-worker/aiologger/maintainability)
  [![Test Coverage](https://api.codeclimate.com/v1/badges/122a3696a749ed04a972/test_coverage)](https://codeclimate.com/github/async-worker/aiologger/test_coverage)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)




  The built-in python logger is I/O blocking. This means that using the built-in
  `logging` module will interfere with your asynchronous application performance.
  `aiologger` aims to be the standard Asynchronous non-blocking logging for
  python and asyncio.




  The project documentation can be found here: https://async-worker.github.io/aiologger/


pkgId: 00fbac616b424c80d3d3fee77737ff0d6e34a1dfa1b25bfd5e4d4b7b5493bcd9
name: python-aiologic
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: GIL-powered* locking library for Python
url: https://pypi.org/project/aiologic/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiologic-0.11.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Copyright 2024 Ilya Egorov <0x42005e1f@gmail.com>.  Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


pkgId: 6fe1e50fd64d3b5af431bd12fc89c7147d295cb9d0d782df91b9623240cd206e
name: python-aiologstash2
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/aviramha/aiologstash2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiologstash2-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [![image](https://travis-ci.org/aio-libs/aiologstash.svg?branch=master)](https://travis-ci.org/aio-libs/aiologstash)

  [![image](https://codecov.io/gh/aio-libs/aiologstash/branch/master/graph/badge.svg)](https://codecov.io/gh/aio-libs/aiologstash)

  [![image](https://badge.fury.io/py/aiologstash.svg)](https://badge.fury.io/py/aiologstash)

  asyncio logging handler for logstash.



  ``` shell
  pip install aiologstash2
  ```



  ``` python
  import logging
  from aiologstash2 import create_tcp_handler

  async def init_logger():
       handler = await create_tcp_handler('127.0.0.1', 5000)
       root = logging.getLogger()
       root.setLevel(logging.DEBUG)
       root.addHandler(handler)
  ```



  This is an actively maintained fork of [aio-libs'
  aiologstash](https://github.com/aio-libs/aiologstash)

  The library was donated by [Ocean S.A.](https://ocean.io/)

  Thanks to the company for contribution.


pkgId: fb2ce759988a7efe288315a9c2b03625d62f2751faf4b5e4775e04286b79aa46
name: python-aiomailru
arch: src
version: 0.1.1.post1
epoch: 0
release: 1
summary: Python Mail.Ru API wrapper
url: https://github.com/KonstantinTogoi/aiomailru
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomailru-0.1.1.post1-1.src.rpm
checksum_type: sha256
description:
  aiomailru is a python `Mail.Ru API <https://api.mail.ru/>`_ wrapper.
  The main features are:
  * authorization (`Authorization Code <https://oauth.net/2/grant-types/authorization-code/>`_, `Implicit Flow <https://oauth.net/2/grant-types/implicit/>`_, `Password Grant <https://oauth.net/2/grant-types/password/>`_, `Refresh Token <https://oauth.net/2/grant-types/refresh-token/>`_)
  * `REST API <https://api.mail.ru/docs/reference/rest/>`_ methods
  * web scrapers


pkgId: e231624586e9832350e1b7ad4da87470e2332aec86a555edffbd883471020938
name: python-aiomanhole
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Python module to provide a manhole in asyncio applications
url: https://github.com/nathan-hoad/aiomanhole
rpm_license: BSD (3-clause)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomanhole-0.7.0-1.src.rpm
checksum_type: sha256
description:
  Manhole for accessing asyncio applications. This is useful for debugging
  application state in situations where you have access to the process, but need
  to access internal application state.
  Adding a manhole to your application is simple::
      from aiomanhole import start_manhole
      start_manhole(namespace={
          'gizmo': application_state_gizmo,
          'whatsit': application_state_whatsit,
      })
  Quick example, in one shell, run this::
      $ python -m aiomanhole
  In a secondary shell, run this::
      $ nc -U /var/tmp/testing.manhole
      Well this is neat
      >>> f = 5 + 5
      >>> f
      10
      >>> import os
      >>> os.getpid()
      4238
      >>> import sys
      >>> sys.exit(0)
  And you'll see the manhole you started has exited.
  The package provides both a threaded and non-threaded interpreter, and allows
  you to share the namespace between clients if you want.


pkgId: ef3297b0e69cac464cb19feacac83380602fbd75ede8ea9ec6f433ea9a9925e4
name: python-aiomas
arch: src
version: 2.0.1
epoch: 0
release: 1
url: https://aiomas.readthedocs.io
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomas-2.0.1-1.src.rpm
checksum_type: sha256
summary:
  Asyncio-based, layered networking library providing request-reply channels, RPC, and multi-agent systems.

description:
  *aiomas* is an easy-to-use library for *request-reply channels*, *remote
  procedure calls (RPC)* and *multi-agent systems (MAS)*.  It’s written in pure
  Python on top of asyncio__.
  Here are three simple examples that show the different layers of aiomas and
  what they add on top of each other:
  The *request-reply channel* has the lowest level of abstraction (but already
  offers more then vanilla asyncio):
     >>> import aiomas
     >>>
     >>>
     >>> async def handle_client(channel):
     >>>
     >>>
     >>> async def client():
     >>>
     >>>
     >>> server = aiomas.run(aiomas.channel.start_server(('localhost', 5555), handle_client))
     >>> aiomas.run(client())
     ohai
     cya
     >>> server.close()
     >>> aiomas.run(server.wait_closed())
  The *RPC layer* adds remote procedure calls on top of it:
     >>> import aiomas
     >>>
     >>>
     >>> class MathServer:
     >>>
     >>> async def client():
     >>>
     >>> server = aiomas.run(aiomas.rpc.start_server(('localhost', 5555), MathServer()))
     >>> aiomas.run(client())
     What’s 3 + 4? 7
     >>> server.close()
     >>> aiomas.run(server.wait_closed())
  Finally, the *agent layer* hides some of the boilerplate code required to setup
  the sockets and allows agent instances to easily talk with each other:
     >>> import aiomas
     >>>
     >>> class TestAgent(aiomas.Agent):
     >>>
     >>> c = aiomas.Container.create(('localhost', 5555))
     >>> agents = [TestAgent(c) for i in range(2)]
     Ohai, I am TestAgent('tcp://localhost:5555/0')
     Ohai, I am TestAgent('tcp://localhost:5555/1')
     >>> aiomas.run(until=agents[0].run(agents[1].addr))
     TestAgent('tcp://localhost:5555/0') got 42 from TestAgentProxy('tcp://localhost:5555/1')
     >>> c.shutdown()
  *aiomas* is released under the MIT license. It requires Python 3.4 and above
  and runs on Linux, OS X, and Windows.
  __ https://docs.python.org/3/library/asyncio.html


pkgId: 03989794534ce4ef833b33de2382f677453526a4680b6694452cd4d981f6576d
name: python-aiomealie
arch: src
version: 0.9.3
epoch: 0
release: 1
summary: Asynchronous Python client for Mealie.
url: https://github.com/joostlek/python-mealie
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomealie-0.9.3-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Release][releases-shield]][releases]
  [![Python Versions][python-versions-shield]][pypi]
  ![Project Stage][project-stage-shield]
  ![Project Maintenance][maintenance-shield]
  [![License][license-shield]](LICENSE.md)

  [![Build Status][build-shield]][build]
  [![Code Coverage][codecov-shield]][codecov]
  [![Code Smells][code-smells]][sonarcloud]

  Asynchronous Python client for Mealie.



  This package allows you to fetch data from your Mealie instance.



  ```bash
  pip install aiomealie
  ```



  This repository keeps a change log using [GitHub's releases][releases]
  functionality. The format of the log is based on
  [Keep a Changelog][keepchangelog].

  Releases are based on [Semantic Versioning][semver], and use the format
  of ``MAJOR.MINOR.PATCH``. In a nutshell, the version will be incremented
  based on the following:

  - ``MAJOR``: Incompatible or major changes.
  - ``MINOR``: Backwards-compatible new features and enhancements.
  - ``PATCH``: Backwards-compatible bugfixes and package updates.



  This is an active open-source project. We are always open to people who want to
  use the code or contribute to it.

  We've set up a separate document for our
  [contribution guidelines](.github/CONTRIBUTING.md).

  Thank you for being involved! :heart_eyes:



  This Python project is fully managed using the [Poetry][poetry] dependency manager. But also relies on the use of NodeJS for certain checks during development.

  You need at least:

  - Python 3.11+
  - [Poetry][poetry-install]
  - NodeJS 12+ (including NPM)

  To install all packages, including all development requirements:

  ```bash
  npm install
  poetry install
  ```

  As this repository uses the [pre-commit][pre-commit] framework, all changes
  are linted and tested with each commit. You can run all checks and tests
  manually, using the following command:

  ```bash
  poetry run pre-commit run --all-files
  ```

  To run just the Python tests:

  ```bash
  poetry run pytest
  ```



  The content is by [Joost Lekkerkerker][joostlek].

  For a full list of all authors and contributors,
  check [the contributor's page][contributors].



  MIT License

  Copyright (c) 2024 Joost Lekkerkerker

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.

  [build-shield]: https://github.com/joostlek/python-mealie/actions/workflows/tests.yaml/badge.svg
  [build]: https://github.com/joostlek/python-mealie/actions
  [code-smells]: https://sonarcloud.io/api/project_badges/measure?project=joostlek_python-mealie&metric=code_smells
  [codecov-shield]: https://codecov.io/gh/joostlek/python-mealie/branch/main/graph/badge.svg
  [codecov]: https://codecov.io/gh/joostlek/python-mealie
  [commits-shield]: https://img.shields.io/github/commit-activity/y/joostlek/python-mealie.svg
  [commits]: https://github.com/joostlek/python-mealie/commits/master
  [contributors]: https://github.com/joostlek/python-mealie/graphs/contributors
  [joostlek]: https://github.com/joostlek
  [keepchangelog]: http://keepachangelog.com/en/1.0.0/
  [license-shield]: https://img.shields.io/github/license/joostlek/python-mealie.svg
  [maintenance-shield]: https://img.shields.io/maintenance/yes/2024.svg
  [poetry-install]: https://python-poetry.org/docs/#installation
  [poetry]: https://python-poetry.org
  [pre-commit]: https://pre-commit.com/
  [project-stage-shield]: https://img.shields.io/badge/project%20stage-stable-green.svg
  [python-versions-shield]: https://img.shields.io/pypi/pyversions/aiomealie
  [releases-shield]: https://img.shields.io/github/release/joostlek/python-mealie.svg
  [releases]: https://github.com/joostlek/python-mealie/releases
  [semver]: http://semver.org/spec/v2.0.0.html
  [sonarcloud]: https://sonarcloud.io/summary/new_code?id=joostlek_python-mealie
  [pypi]: https://pypi.org/project/aiomealie/


pkgId: c4ba4a68cde276fd7efffb79044cf82c701860486d2719cc79eae792e54aee89
name: python-aiomemoizettl
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Memoize asyncio Python calls with a per-result TTL
url: https://github.com/michalc/aiomemoizettl
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomemoizettl-0.0.3-1.src.rpm
checksum_type: sha256
description:
  Memoize asyncio Python calls with a per-result TTL




  ```base
  pip install aiomemoizettl
  ```




  For a coroutine whose arguments are hashable, you can create a _memoized_ version by passing it to `memoize_ttl`, along with a function that converts its return value to a TTL.

  For example, the below

  ```python
  import asyncio
  from aiomemoizettl import memoize_ttl

  async def main():
      memoized = memoize_ttl(coro, get_ttl=lambda result: result['ttl'])
      results = await asyncio.gather(*[
          memoized(1),
          memoized(2),
      ])
      await asyncio.sleep(1)

      results = await asyncio.gather(*[
          memoized(1),
          memoized(2),  # Will used the cached value of `coro(2)`
      ])

  async def coro(value):
      print('Inside coro', value)
      return {'ttl': value, 'some-other': 'data'}

  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())
  loop.close()
  ```

  will output

  ```
  Inside coro 1
  Inside coro 2
  Inside coro 1
  ```


pkgId: f4341256a0e919cb8f7663936969a725d6c6545870f23b53f7c41d06980ca214
name: python-aiomeshtastic
arch: src
version: 6
epoch: 0
release: 1
summary: asyncio bindings to the meshtastic device API.
url: https://pypi.org/project/aiomeshtastic/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomeshtastic-6-1.src.rpm
checksum_type: sha256
description:
  Currenyly this can connect to devices over bluetooth, TCP, and serial. The
  allows you to loop over a device to get protobufs as they arrive and you can
  send protobufs back.
  See examples/tr.py for how it can be used.


pkgId: a185f9d875ca3484488a07c20b3f853bc33a29ffc6fbe4e2460c595cb8e63648
name: python-aiometer
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A Python concurrency scheduling library, compatible with asyncio and trio
url: https://github.com/florimondmanca/aiometer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiometer-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://dev.azure.com/florimondmanca/public/_apis/build/status/florimondmanca.aiometer?branchName=master)](https://dev.azure.com/florimondmanca/public/_build/latest?definitionId=4&branchName=master)
  [![Coverage](https://codecov.io/gh/florimondmanca/aiometer/branch/master/graph/badge.svg)](https://codecov.io/gh/florimondmanca/aiometer)
  ![Python versions](https://img.shields.io/pypi/pyversions/aiometer.svg)
  [![Package version](https://badge.fury.io/py/aiometer.svg)](https://pypi.org/project/aiometer)

  `aiometer` is a concurrency scheduling library compatible with `asyncio` and `trio` and inspired by [Trimeter](https://github.com/python-trio/trimeter). It makes it easier to execute lots of tasks concurrently while controlling concurrency limits (i.e. applying _[backpressure](https://lucumr.pocoo.org/2020/1/1/async-pressure/)_) and collecting results in a predictable manner.

  **Content**

  - [Example](#example)
  - [Features](#features)
  - [Installation](#installation)
  - [Usage](#usage)
    - [Flow control](#flow-control)
    - [Running tasks](#running-tasks)
  - [How To](#how-to)
  - [API Reference](#api-reference)
  - [Contributing](#contributing)
  - [License](#license)



  Let's use [HTTPX](https://github.com/encode/httpx) to make web requests concurrently...

  _Try this code interactively using [IPython](https://ipython.org/install.html)._

  ```python
  >>> import asyncio
  >>> import functools
  >>> import random
  >>> import aiometer
  >>> import httpx
  >>>
  >>> client = httpx.AsyncClient()
  >>>
  >>> async def fetch(client, request):
  ...     response = await client.send(request)
  ...     # Simulate extra processing...
  ...     await asyncio.sleep(2 * random.random())
  ...     return response.json()["json"]
  ...
  >>> requests = [
  ...     httpx.Request("POST", "https://httpbin.org/anything", json={"index": index})
  ...     for index in range(100)
  ... ]
  ...
  >>> # Send requests, and process responses as they're made available:
  >>> async with aiometer.amap(
  ...     functools.partial(fetch, client),
  ...     requests,
  ...     max_at_once=10, # Limit maximum number of concurrently running tasks.
  ...     max_per_second=5,  # Limit request rate to not overload the server.
  ... ) as results:
  ...     async for data in results:
  ...         print(data)
  ...
  {'index': 3}
  {'index': 4}
  {'index': 1}
  {'index': 2}
  {'index': 0}
  ...
  >>> # Alternatively, fetch and aggregate responses into an (ordered) list...
  >>> jobs = [functools.partial(fetch, client, request) for request in requests]
  >>> results = await aiometer.run_all(jobs, max_at_once=10, max_per_second=5)
  >>> results
  [{'index': 0}, {'index': 1}, {'index': 2}, {'index': 3}, {'index': 4}, ...]
  ```



  _This project is in beta and maturing. Be sure to pin any dependencies to the latest minor._

  ```bash
  pip install "aiometer==0.5.*"
  ```



  - Concurrency management and throttling helpers.
  - `asyncio` and `trio` support.
  - Fully type annotated.
  - 100% test coverage.





  The key highlight of `aiometer` is allowing you to apply flow control strategies in order to limit the degree of concurrency of your programs.

  There are two knobs you can play with to fine-tune concurrency:

  - `max_at_once`: this is used to limit the maximum number of concurrently running tasks at any given time. (If you have 100 tasks and set `max_at_once=10`, then `aiometer` will ensure that no more than 10 run at the same time.)
  - `max_per_second`: this option limits the number of tasks spawned per second. This is useful to not overload I/O resources, such as servers that may have a rate limiting policy in place.

  Example usage:

  ```python
  >>> import asyncio
  >>> import aiometer
  >>> async def make_query(query):
  ...     await asyncio.sleep(0.05)  # Simulate a database request.
  ...
  >>> queries = ['SELECT * from authors'] * 1000
  >>> # Allow at most 5 queries to run concurrently at any given time:
  >>> await aiometer.run_on_each(make_query, queries, max_at_once=5)
  ...
  >>> # Make at most 10 queries per second:
  >>> await aiometer.run_on_each(make_query, queries, max_per_second=10)
  ...
  >>> # Run at most 10 concurrent jobs, spawning new ones at least every 5 seconds:
  >>> async def job(id):
  ...     await asyncio.sleep(10)  # A very long task.
  ...
  >>> await aiometer.run_on_each(job, range(100),  max_at_once=10, max_per_second=0.2)
  ```



  `aiometer` provides 4 different ways to run tasks concurrently in the form of 4 different run functions. Each function accepts all the options documented in [Flow control](#flow-control), and runs tasks in a slightly different way, allowing to address a variety of use cases. Here's a handy table for reference (see also the [API Reference](#api-reference)):

  | Entrypoint      | Use case                                       |
  | --------------- | ---------------------------------------------- |
  | `run_on_each()` | Execute async callbacks in any order.          |
  | `run_all()`     | Return results as an ordered list.             |
  | `amap()`        | Iterate over results as they become available. |
  | `run_any()`     | Return result of first completed function.     |

  To illustrate the behavior of each run function, let's first setup a hello world async program:

  ```python
  >>> import asyncio
  >>> import random
  >>> from functools import partial
  >>> import aiometer
  >>>
  >>> async def get_greeting(name):
  ...     await asyncio.sleep(random.random())  # Simulate I/O
  ...     return f"Hello, {name}"
  ...
  >>> async def greet(name):
  ...     greeting = await get_greeting(name)
  ...     print(greeting)
  ...
  >>> names = ["Robert", "Carmen", "Lucas"]
  ```

  Let's start with `run_on_each()`. It executes an async function once for each item in a list passed as argument:

  ```python
  >>> await aiometer.run_on_each(greet, names)
  'Hello, Robert!'
  'Hello, Lucas!'
  'Hello, Carmen!'
  ```

  If we'd like to get the list of greetings in the same order as `names`, in a fashion similar to [`Promise.all()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all), we can use `run_all()`:

  ```python
  >>> await aiometer.run_all([partial(get_greeting, name) for name in names])
  ['Hello, Robert', 'Hello, Carmen!', 'Hello, Lucas!']
  ```

  `amap()` allows us to process each greeting as it becomes available (which means maintaining order is not guaranteed):

  ```python
  >>> async with aiometer.amap(get_greeting, names) as greetings:
  ...     async for greeting in greetings:
  ...         print(greeting)
  'Hello, Lucas!'
  'Hello, Robert!'
  'Hello, Carmen!'
  ```

  Lastly, `run_any()` can be used to run async functions until the first one completes, similarly to [`Promise.any()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/any):

  ```python
  >>> await aiometer.run_any([partial(get_greeting, name) for name in names])
  'Hello, Carmen!'
  ```

  As a last fun example, let's use `amap()` to implement a no-threads async version of [sleep sort](https://rosettacode.org/wiki/Sorting_algorithms/Sleep_sort):

  ```python
  >>> import asyncio
  >>> from functools import partial
  >>> import aiometer
  >>> numbers = [0.3, 0.1, 0.6, 0.2, 0.7, 0.5, 0.5, 0.2]
  >>> async def process(n):
  ...     await asyncio.sleep(n)
  ...     return n
  ...
  >>> async with aiometer.amap(process, numbers) as results:
  ...     sorted_numbers = [n async for n in results]
  ...
  >>> sorted_numbers
  [0.1, 0.2, 0.2, 0.3, 0.5, 0.5, 0.6, 0.7]
  ```





  `run_on_each` and `amap` only accept functions that accept a single positional argument (i.e. `(Any) -> Awaitable`).

  So if you have a function that is parametrized by multiple values, you should refactor it to match this form.

  This can generally be achieved like this:

  1. Build a proxy container type (eg. a `namedtuple`), eg `T`.
  2. Refactor your function so that its signature is now `(T) -> Awaitable`.
  3. Build a list of these proxy containers, and pass it to `aiometer`.

  For example, assuming you have a function that processes X/Y coordinates...

  ```python
  async def process(x: float, y: float) -> None:
      pass

  xs = list(range(100))
  ys = list(range(100))

  for x, y in zip(xs, ys):
      await process(x, y)
  ```

  You could use it with `amap` by refactoring it like this:

  ```python
  from typing import NamedTuple


  class Point(NamedTuple):
      x: float
      y: float


  async def process(point: Point) -> None:
      x = point.x
      y = point.y
      ...

  xs = list(range(100))
  ys = list(range(100))


  points = [Point(x, y) for x, y in zip(x, y)]


  async with aiometer.amap(process, points) as results:
      ...
  ```





  * `max_at_once` (_Optional_, `int`): the maximum number of concurrently running tasks at any given time.
  * `max_per_second` (_Optional_, `int`): the maximum number of tasks spawned per second.



  **Signature**: _async_ aiometer.run_on_each(*async_fn*, *args*, *, *max_at_once=None*, *max_per_second=None*) -> *None*

  Concurrently run the equivalent of `async_fn(arg) for arg in args`. Does not return any value. To get return values back, use [`aiometer.run_all()`](#aiometerrun_all).



  **Signature**: _async_ aiometer.run_all(*async_fns*, *max_at_once=None*, *max_per_second=None*) -> *list*

  Concurrently run the `async_fns` functions, and return the list of results in the same order.



  **Signature**: _async_ aiometer.amap(*async_fn*, *args*, *max_at_once=None*, *max_per_second=None*) -> *async iterator*

  Concurrently run the equivalent of `async_fn(arg) for arg in args`, and return an async iterator that yields results as they become available.



  **Signature**: _async_ aiometer.run_any(*async_fns*, *max_at_once=None*, *max_per_second=None*) -> *Any*

  Concurrently run the `async_fns` functions, and return the first available result.



  See [CONTRIBUTING.md](./CONTRIBUTING.md).



  MIT



  All notable changes to this project will be documented in this file.

  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).





  - Drop support for Python 3.7, as it has reached EOL. (Pull #44)



  - Add official support for Python 3.12. (Pull #44)
  - Add support for anyio 4. This allows catching exception groups using the native ExceptionGroup. On anyio 3.2+, anyio would throw its own ExceptionGroup type. Compatibility with anyio 3.2+ is retained. (Pull #43)





  - Drop support for Python 3.6, which has reached EOL. (Pull #38)



  - Add official support for Python 3.10 and 3.11. (Pull #38)



  - Relax version requirements for `typing_extensions` and address `mypy>=0.981` strict optional changes. (Pull #38)





  - Update `anyio` dependency to v3 (previously v1). (Pull #25)
    - _NB: no API change, but dependency mismatches may occur. Be sure to port your codebase to anyio v3 before upgrading `aiometer`._



  - Add support for Python 3.6 (installs the `contextlib2` backport library there). (Pull #26)
  - Officialize support for Python 3.9. (Pull #26)





  - Improve robustness of the `max_per_second` implementation by using the generic cell rate algorithm (GCRA) instead of leaky bucket. (Pull #5)





  - Add support for Python 3.7. (Pull #3)





  - Add `run_on_each()`, `run_all()`, `amap()` and `run_any()`, with `max_at_once` and `max_per_second` options. (Pull #1)


pkgId: 38fbc8f6480d5179276e0aa3db22e86cf739cfea1662093c5805748458f16b06
name: python-aiomirai
arch: src
version: 0.3.8
epoch: 0
release: 1
summary: A framework for Tencent QQ headless client 'Mirai'.
url: https://github.com/AsakuraMizu/aiomirai
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomirai-0.3.8-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/water-lift/aiomirai.svg)](LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/aiomirai.svg)](https://pypi.python.org/pypi/aiomirai)

  Async Mirai SDK for Python is a Python SDK with async I/O for [Mirai](https://github.com/mamoe/mirai)'s [Mirai API HTTP](https://github.com/mamoe/mirai-api-http) plugin.

  Inspired by [CQHTTP Python Async SDK](https://github.com/cqmoe/python-aiocqhttp) and [Mirai Framework for Python](https://github.com/NatriumLab/python-mirai).



  ```bash
  pip install aiomirai
  ```



  See at [https://aiomirai.solariar.tech](https://aiomirai.solariar.tech)



  > 这些项目也很棒, 去他们的项目页看看, 点个 `Star` 以鼓励他们的开发工作, 毕竟没有他们也没有 `aiomirai`.

  特别感谢 [`mamoe`](https://github.com/mamoe) 给我们带来这些精彩的项目:
   - [`mirai`](https://github.com/mamoe/mirai): 即 `mirai-core`, 一个高性能, 高可扩展性的 QQ 协议库, 同时也是个很棒的机器人开发框架!
   - [`mirai-console`](https://github.com/mamoe/mirai-console): 一个基于 `mirai` 开发的插件式可扩展开发平台, 我们的大多数开发工作基本上都在该项目上完成, 不得不称赞其带来的开发敏捷性.
   - [`mirai-api-http`](https://github.com/mamoe/mirai-api-http): 为该项目提供 `http` 接口的 `mirai-console` 插件, 万物之源

  特别感谢 [`NatriumLab`](https://github.com/NatriumLab) 给我们带来这些精彩的项目:
    - [`python-mirai`](https://github.com/NatriumLab/python-mirai)：一个以 OICQ(QQ) 协议驱动的高性能机器人开发框架 Mirai 的 Python 接口，本项目的灵感来源，参考了部分内容~~比如这个鸣谢~~

  特别感谢 [`CQMOE`](https://github.com/cqmoe) 给我们带来这些精彩的项目:
    - [`python-aiocqhttp`](https://github.com/cqmoe/python-aiocqhttp/)：酷Q 的 CQHTTP 插件 的 Python SDK 异步版本，本项目的主要代码及逻辑都在一定程度上参考了该项目

  特别感谢 [`Koishi.js`](https://github.com/koishijs) 给我们带来这些精彩的项目：
    - [`koishijs.github.io`](https://github.com/koishijs/koishijs.github.io)：本项目文档的部分内容使用了该项目中的 vue 组件

  And finally...

  ```
  Long Live Mirai
                   `-://+++//:-.
                 -+o+o++oo+o+++////:-.`
             ``-o+/:+o:+++//++s+++/////:`
           `--/++//+os://+/::+o+::/:/--::.
           :://o/:-:o+:/`./-:+-.//:/://`:/:-.`
          -+/+:o/--:/--:.`.:-.-+o/+o++:- +-`:/:-
         ./::o:o+/+::.ohy:````-ss+/os+:`.-:` .--
      ```.-/`+:++:/o/+++:.``````.`-o/:. -` ...```
        `- -:/-`///+o+:````...-.`.:+/.``
       .-. ``:. ...::::--....``.-----..:.
       .:-.-    `....`----.-...-.---:.`--.`
    `..--::.    -.```...-:  `.--`-..-`-`-`..`
    ..:--...   `.--     `.-```.-  `..`. .....`
     ....``-  `-...-      :-  `.`  `..`  -`-..`
     `.:``./...`.```..``..//  `..   ..-.```.-```
   `-:-:...-...``.`.````..//` ````  ../:    .`.``
   ......     +:.```.   . //` `.`.  .://    ````.`
    ....``  `.shy+.`.  `.`-/: `-`.. `+/-    -````.
     .```.````/os/../  `---//` :``-  //.   `-`.```.`
     .`````````..`..-` -+oo+/- .``.. :/.  ```..````-:`
     .``.```````-.-`:  .-::-// .`.`-`./.    -:-.```-/.`
     `.`.``````./-`/+`   `  -/``.:--.`/-  ./+..-```:/``-
      `-.`````.` ``:++:   ` -/. `.`.. /:  .- `  ..-/-``.-.`
       `.....`  ``  `-/`    ./-  .:- `:/`    .   --.```.....`
                `            `   ` `  ``
            ``.`   ````  ``                 ``
            /++/` `+++:  -.     ``   ```    `.
            /+-+/ :/-+: `+/  -:...`.-.`.--  -:`
            /+..+/+-.+: `+/  -:    .-..`-:` -:`
            -/` -/- `/- `/:  --    .-....-` .-`
  ```


pkgId: 7ece2c9789c6ca966c6535642811b7e8dd003a475fa04b90b597ee175568b884
name: python-aiomisc
arch: src
version: 17.5.26
epoch: 0
release: 1
summary: aiomisc - miscellaneous utils for asyncio
url: https://github.com/aiokitchen/aiomisc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomisc-17.5.26-1.src.rpm
checksum_type: sha256
description:
  Miscellaneous utils for asyncio.
  As a programmer, you are no stranger to the challenges that come with building
  and maintaining software applications. One area that can be particularly
  difficult is making architecture of the software that using asynchronous I/O.
  This is where aiomisc comes in. aiomisc is a Python library that provides a
  collection of utility functions and classes for working with asynchronous I/O
  in a more intuitive and efficient way. It is built on top of the ``asyncio``
  library and is designed to make it easier for developers to write
  asynchronous code that is both reliable and scalable.
  With aiomisc, you can take advantage of powerful features like
  ``worker pools``, ``connection pools``, ``circuit breaker pattern``,
  and retry mechanisms such as ``asyncbackoff`` and ``asyncretry`` to make your
  asyncio code more robust and easier to maintain. In this documentation,
  we'll take a closer look at what ``aiomisc`` has to offer and how it can
  help you streamline your asyncio service development.


pkgId: 079baad0ba28fa0ac0323208de46467292fbe992ef7789e7ed4a19319174cdca
name: python-aiomisc-dependency
arch: src
version: 0.1.20
epoch: 0
release: 1
summary: aiomisc-dependency - dependency injection in aiomisc
url: https://github.com/aiokitchen/aiomisc-dependency
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomisc-dependency-0.1.20-1.src.rpm
checksum_type: sha256
description:
  Dependency injection plugin for aiomisc_ built with aiodine_ library and
  support pytest fixture style dependency injection.


pkgId: 175c9813fc5a570d804f06515ea7df626459b85239d3a7794bd333a583503a71
name: python-aiomixcloud
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: Mixcloud API wrapper for Python and Async IO
url: https://github.com/amikrop/aiomixcloud
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomixcloud-1.0.6-1.src.rpm
checksum_type: sha256
description:
  *aiomixcloud* is a wrapper library for the `HTTP API
  <https://www.mixcloud.com/developers/>`_ of `Mixcloud
  <https://www.mixcloud.com/>`_.  It supports asynchronous operation via
  `asyncio <https://docs.python.org/3/library/asyncio.html>`_ and specifically
  the `aiohttp <https://aiohttp.readthedocs.io/en/stable/>`_ framework.
  *aiomixcloud* tries to be abstract and independent of the API's transient
  structure, meaning it is not tied to specific JSON fields and resource types.
  That is, when the API changes or expands, the library should be ready to
  handle it.


pkgId: 48deb45afce2f8b9c12788bd9acdda03f6f37ba2a115a819882929a6e7684cec
name: python-aiomodernforms
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Asynchronous Python client for Modern Forms fans.
url: https://github.com/wonderslug/aiomodernforms
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomodernforms-0.1.8-1.src.rpm
checksum_type: sha256
description:
  ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/wonderslug/aiomodernforms/Continuous%20Integration)
  ![Codecov](https://img.shields.io/codecov/c/github/wonderslug/aiomodernforms)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  ![PyPI](https://img.shields.io/pypi/v/aiomodernforms)

  Asynchronous Python client for Modern Forms Fans.



  This package allows you to control and monitor Modern Forms fans
  programmatically. It is mainly created to allow third-party programs to automate
  the behavior of the Modern Forms fans



  ```bash
  pip install aiomodernforms
  ```



  ```python
  """Asynchronous Python client for Async IO Modern Forms fan."""
  import asyncio
  from datetime import datetime, timedelta

  import aiomodernforms
  from aiomodernforms.const import LIGHT_POWER_ON


  async def main():
      """Turn on the fan light."""
      async with aiomodernforms.ModernFormsDevice("192.168.3.197") as fan:
          await fan.update()
          print(fan.status)
          await fan.light(
              on=LIGHT_POWER_ON,
              brightness=50,
              sleep=datetime.now() + timedelta(minutes=2),
          )
          print(fan.status)


  if __name__ == "__main__":
      loop = asyncio.get_event_loop()
      loop.run_until_complete(main())
  ```


pkgId: f1eefb1f3fe0cb92aa6b9f9bc4ad1e0c233d81246d978fec24ebd796f5dcbaaf
name: python-aiomoex
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: Asyncio MOEX ISS API
url: https://pypi.org/project/aiomoex/
rpm_license: http://unlicense.org
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomoex-2.1.2-1.src.rpm
checksum_type: sha256
description:
  Реализация на основе asyncio части  запросов к `MOEX Informational & Statistical Server <https://www.moex.com/a2193>`_.


pkgId: eae7cbf141e327347fb99d7a3231423b557eaa9666122691acdbd34049757937
name: python-aiomoney
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Простая асинхронная библиотека для работы с API ЮMoney
url: https://github.com/fofmow/aiomoney
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomoney-2.0.1-1.src.rpm
checksum_type: sha256
description:
  1. Зарегистрируйте новое приложение YooMoney по ссылке https://yoomoney.ru/myservices/new
     (без указания чекбокса OAuth2!).
  2. Получите и скопируйте `client_id` после создания приложения
  3. Создайте запрос на получение api-токена.
     [О правах приложения](https://yoomoney.ru/docs/wallet/using-api/authorization/protocol-rights)

     ```python
     import asyncio
     from os import environ
     from aiomoney import authorize_app


     async def main():
         await authorize_app(
             client_id=environ.get("CLIENT_ID"),
             redirect_uri=environ.get("REDIRECT_URI"),
             app_permissions=[
                 "account-info",
                 "operation-history",
                 "operation-details",
                 "incoming-transfers",
                 "payment-p2p",
                 "payment-shop",
             ]
         )


     if __name__ == "__main__":
         asyncio.run(main())
     ```

  4. Во время перенаправления по `redirect_uri` в адресной строке появится параметр `code=`.
     Скопируйте значение и вставьте его в консоль
  5. Если авторизация прошла успешно, в консоли отобразится Ваш api-token.
     Сохраните его в переменную окружения (рекомендация)



  ```python
  import asyncio
  from aiomoney.types import AccountInfo, Operation, OperationDetails
  from aiomoney.wallet import YooMoneyWallet


  async def main():
      wallet = YooMoneyWallet(access_token="ACCESS_TOKEN")

      account_info: AccountInfo = await wallet.account_info
      operation_history: list[Operation] = await wallet.get_operation_history()
      operation_details: OperationDetails = await wallet.get_operation_details(operation_id="999")


  if __name__ == "__main__":
      asyncio.run(main())
  ```



  ```python
  import asyncio
  from aiomoney.wallet import YooMoneyWallet, PaymentSource


  async def main():
      wallet = YooMoneyWallet(access_token="ACCESS_TOKEN")

      payment_form = await wallet.create_payment_form(
          amount_rub=990,
          unique_label="myproject_second_unicorn",
          payment_source=PaymentSource.YOOMONEY_WALLET,
          success_redirect_url="https://t.me/fofmow (nonono =/)"
      )
      
      payment_is_completed: bool = await wallet.check_payment_on_successful(payment_form.payment_label)

      print(f"Ссылка на оплату:\n{payment_form.link_for_customer}\n\n"
            f"Форма оплачена: {'Да' if payment_is_completed else 'Нет'}")


  if __name__ == "__main__":
      asyncio.run(main())

  ```


pkgId: 69ab0e67e5890a120f1e220ca4590630ea8cfb05435232b18a84418edc3a6600
name: python-aiomql
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: Asynchronous MetaTrader5 library and Algorithmic Trading Framework
url: https://github.com/Ichinga-Samuel/aiomql
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomql-4.0.0-1.src.rpm
checksum_type: sha256
description:
  ![GitHub](https://img.shields.io/github/license/ichinga-samuel/aiomql?style=plastic)
  ![GitHub issues](https://img.shields.io/github/issues/ichinga-samuel/aiomql?style=plastic)
  ![PyPI](https://img.shields.io/pypi/v/aiomql)



  ```bash
  pip install aiomql
  ```


  - Asynchronous Python Library For MetaTrader5
  - Asynchronous Bot Building Framework
  - Build bots for trading in different financial markets.
  - Use threadpool executors to run multiple strategies on multiple instruments concurrently
  - Records and keep track of trades and strategies in csv files.
  - Helper classes for Bot Building. Easy to use and extend.
  - Compatible with pandas-ta.
  - Sample Pre-Built strategies
  - Specify and Manage Trading Sessions
  - Risk Management
  - Backtesting Engine
  - Run multiple bots concurrently with different accounts from the same broker or different brokers
  - Easy to use and very accurate backtesting engine


  ```python
  import asyncio

  from aiomql import MetaTrader


  async def main():
      mt5 = MetaTrader()
      res = await mt5.initialize(login=31288540, password='nwa0#anaEze', server='Deriv-Demo')
      if not res:
          print('Unable to login and initialize')
          return
      
      acc = await mt5.account_info()
      print(acc)
      
      symbols = await mt5.symbols_get()
      print(symbols)

  asyncio.run(main())
  ```


  Aiomql allows you to focus on building trading strategies and not worry about the underlying infrastructure.
  It provides a simple and easy to use framework for building bots with rich features and functionalities.


  ```python
  from datetime import time
  import logging

  from aiomql import Bot, ForexSymbol, FingerTrap, Session, Sessions, RAM, SimpleTrader, TimeFrame, Chaos

  logging.basicConfig(level=logging.INFO)


  def build_bot():
      bot = Bot()
      
      params = {'fast_period': 8, 'slow_period': 34, 'etf': TimeFrame.M5}
      symbols = ['GBPUSD', 'AUDUSD', 'USDCAD', 'EURGBP', 'EURUSD']
      symbols = [ForexSymbol(name=sym) for sym in symbols]
      strategies = [FingerTrap(symbol=sym, params=params)for sym in symbols]
      bot.add_strategies(strategies)

      
      
      
      london = Session(name='London', start=time(8, 0), end=time(16, 0))
      new_york = Session(name='New York', start=time(13, 0), end=time(21, 0))
      tokyo = Session(name='Tokyo', start=time(0, 0), end=time(8, 0))

      sessions = Sessions(sessions=[london, new_york, tokyo])
      jpy_strategy = Chaos(symbol=ForexSymbol(name='USDJPY'), sessions=sessions)
      bot.add_strategy(strategy=jpy_strategy)
      bot.execute()


  build_bot()
  ```


  Aiomql provides a very accurate backtesting engine that allows you to test your trading strategies before deploying
  them in the market. The backtest engine prioritizes accuracy over speed, but allows you to increase the speed
  as desired. It is very easy to use and provides a lot of flexibility. The backtester is designed to run strategies
  seamlessly without need for modification of the strategy code. When running in backtest mode all the classes that
  needs to know if they are running in backtest mode will be able to do so and adjust their behavior accordingly.

  ```python
  from aiomql import MetaBackTester, BackTestEngine, MetaTrader
  import logging
  from datetime import datetime, UTC

  from aiomql.lib.backtester import BackTester
  from aiomql.core import Config
  from aiomql.contrib.strategies import FingerTrap
  from aiomql.contrib.symbols import ForexSymbol
  from aiomql.core.backtesting import BackTestEngine


  def back_tester():
      config = Config(mode="backtest")
      logging.basicConfig(level=logging.INFO, format="s - s - s - s")
      syms = ["Volatility 75 Index", "Volatility 100 Index", "Volatility 25 Index", "Volatility 10 Index"]
      symbols = [ForexSymbol(name=sym) for sym in syms]
      strategies = [FingerTrap(symbol=symbol) for symbol in symbols]

      
      start = datetime(2024, 5, 1, tzinfo=UTC)
      stop_time = datetime(2024, 5, 2, tzinfo=UTC)
      end = datetime(2024, 5, 7, tzinfo=UTC)

      
      back_test_engine = BackTestEngine(start=start, end=end, speed=3600, stop_time=stop_time,
                                        close_open_positions_on_exit=True, assign_to_config=True, preload=True,
                                        account_info={"balance": 350})
      
      backtester = BackTester(backtest_engine=back_test_engine)
      
      backtester.add_strategies(strategies=strategies)
      backtester.execute()


  back_tester()
  ```


  Aiomql provides a simple and easy to use framework for building trading strategies. You can easily extend the
  framework to build your own custom strategies. Below is an example of a simple strategy that buys when the fast
  moving average crosses above the slow moving average and sells when the fast moving average crosses below the slow
  moving average.

  ```python

  from aiomql import Strategy, ForexSymbol, TimeFrame, Tracker, OrderType, Sessions, Trader, ScalpTrader


  class EMAXOver(Strategy):
      ttf: TimeFrame  # time frame for the strategy
      tcc: int  # how many candles to consider
      fast_ema: int  # fast moving average period
      slow_ema: int  # slow moving average period
      tracker: Tracker  # tracker to keep track of strategy state
      interval: TimeFrame  # intervals to check for entry and exit signals
      timeout: int  # timeout after placing an order in seconds

      
      
      parameters = {'ttf': TimeFrame.H1, 'tcc': 3000, 'fast_ema': 34, 'slow_ema': 55, 'interval': TimeFrame.M15,
                    'timeout': 3 * 60 * 60}

      def __init__(self, *, symbol: ForexSymbol, params: dict | None = None, trader: Trader = None,
                   sessions: Sessions = None, name: str = "EMAXOver"):
          super().__init__(symbol=symbol, params=params, sessions=sessions, name=name)
          self.tracker = Tracker(snooze=self.interval.seconds)
          self.trader = trader or ScalpTrader(symbol=self.symbol)

      async def find_entry(self):
          
          candles = await self.symbol.copy_rates_from_pos(timeframe=self.ttf, start_position=0, count=self.tcc)

          
          candles.ta.ema(length=self.fast_ema, append=True)
          
          candles.ta.ema(length=self.slow_ema, append=True)
          
          candles.rename(**{f"EMA_{self.fast_ema}": "fast_ema", f"EMA_{self.slow_ema}": "slow_ema"}, inplace=True)

          
          
          fas = candles.ta_lib.cross(candles.fast_ema, candles.slow_ema, above=True)
          
          fbs = candles.ta_lib.cross(candles.fast_ema, candles.slow_ema, above=False)

          
          if fas.iloc[-1]:
              self.tracker.update(order_type=OrderType.BUY, snooze=self.timeout)
          elif fbs.iloc[-1]:
              self.tracker.update(order_type=OrderType.SELL, snooze=self.timeout)
          else:
              self.tracker.update(order_type=None, snooze=self.interval.seconds)

      async def trade(self):
          await self.find_entry()
          if self.tracker.order_type is None:
              await self.sleep(secs=self.tracker.snooze)
          else:
              await self.trader.place_trade(order_type=self.tracker.order_type, parameters=self.parameters)
              await self.delay(secs=self.tracker.snooze)

  ```



  Run the tests with pytest

  ```bash
  pytest test
  ```


  see [API Documentation](docs) for more details


  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.


  Feeling generous, like the package or want to see it become a more mature package?

  Consider supporting the project by buying me a coffee.


  [!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/ichingasamuel)


pkgId: b6adfc1267a65a90fcc5b352346095cc9887f2b3c183afb1201160ed6c324bdd
name: python-aiomql
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: Asynchronous MetaTrader5 library and Algorithmic Trading Framework
url: https://github.com/Ichinga-Samuel/aiomql
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomql-4.1.0-1.src.rpm
checksum_type: sha256
description:
  ![GitHub](https://img.shields.io/github/license/ichinga-samuel/aiomql?style=plastic)
  ![GitHub issues](https://img.shields.io/github/issues/ichinga-samuel/aiomql?style=plastic)
  ![PyPI](https://img.shields.io/pypi/v/aiomql)



  ```bash
  pip install aiomql
  ```


  - Asynchronous Python Library For MetaTrader5
  - Asynchronous Bot Building Framework
  - Build bots for trading in different financial markets.
  - Use threadpool executors to run multiple strategies on multiple instruments concurrently
  - Records and keep track of trades and strategies in csv files.
  - Helper classes for Bot Building. Easy to use and extend.
  - Compatible with pandas-ta.
  - Sample Pre-Built strategies
  - Specify and Manage Trading Sessions
  - Risk Management
  - Backtesting Engine
  - Run multiple bots concurrently with different accounts from the same broker or different brokers
  - Easy to use and very accurate backtesting engine


  ```python
  import asyncio

  from aiomql import MetaTrader


  async def main():
      mt5 = MetaTrader()
      res = await mt5.initialize(login=31288540, password='nwa0#anaEze', server='Deriv-Demo')
      if not res:
          print('Unable to login and initialize')
          return
      
      acc = await mt5.account_info()
      print(acc)
      
      symbols = await mt5.symbols_get()
      print(symbols)

  asyncio.run(main())
  ```


  Aiomql allows you to focus on building trading strategies and not worry about the underlying infrastructure.
  It provides a simple and easy to use framework for building bots with rich features and functionalities.


  ```python
  from datetime import time
  import logging

  from aiomql import Bot, ForexSymbol, FingerTrap, Session, Sessions, RAM, SimpleTrader, TimeFrame, Chaos

  logging.basicConfig(level=logging.INFO)


  def build_bot():
      bot = Bot()
      
      params = {'fast_period': 8, 'slow_period': 34, 'etf': TimeFrame.M5}
      symbols = ['GBPUSD', 'AUDUSD', 'USDCAD', 'EURGBP', 'EURUSD']
      symbols = [ForexSymbol(name=sym) for sym in symbols]
      strategies = [FingerTrap(symbol=sym, params=params)for sym in symbols]
      bot.add_strategies(strategies)

      
      
      
      london = Session(name='London', start=time(8, 0), end=time(16, 0))
      new_york = Session(name='New York', start=time(13, 0), end=time(21, 0))
      tokyo = Session(name='Tokyo', start=time(0, 0), end=time(8, 0))

      sessions = Sessions(sessions=[london, new_york, tokyo])
      jpy_strategy = Chaos(symbol=ForexSymbol(name='USDJPY'), sessions=sessions)
      bot.add_strategy(strategy=jpy_strategy)
      bot.execute()


  build_bot()
  ```


  Aiomql provides a very accurate backtesting engine that allows you to test your trading strategies before deploying
  them in the market. The backtest engine prioritizes accuracy over speed, but allows you to increase the speed
  as desired. It is very easy to use and provides a lot of flexibility. The backtester is designed to run strategies
  seamlessly without need for modification of the strategy code. When running in backtest mode all the classes that
  needs to know if they are running in backtest mode will be able to do so and adjust their behavior accordingly.

  ```python
  from aiomql import MetaBackTester, BackTestEngine, MetaTrader
  import logging
  from datetime import datetime, UTC

  from aiomql.lib.backtester import BackTester
  from aiomql.core import Config
  from aiomql.contrib.strategies import FingerTrap
  from aiomql.contrib.symbols import ForexSymbol
  from aiomql.core.backtesting import BackTestEngine


  def back_tester():
      config = Config(mode="backtest")
      logging.basicConfig(level=logging.INFO, format="s - s - s - s")
      syms = ["Volatility 75 Index", "Volatility 100 Index", "Volatility 25 Index", "Volatility 10 Index"]
      symbols = [ForexSymbol(name=sym) for sym in syms]
      strategies = [FingerTrap(symbol=symbol) for symbol in symbols]

      
      start = datetime(2024, 5, 1, tzinfo=UTC)
      stop_time = datetime(2024, 5, 2, tzinfo=UTC)
      end = datetime(2024, 5, 7, tzinfo=UTC)

      
      back_test_engine = BackTestEngine(start=start, end=end, speed=3600, stop_time=stop_time,
                                        close_open_positions_on_exit=True, assign_to_config=True, preload=True,
                                        account_info={"balance": 350})
      
      backtester = BackTester(backtest_engine=back_test_engine)
      
      backtester.add_strategies(strategies=strategies)
      backtester.execute()


  back_tester()
  ```


  Aiomql provides a simple and easy to use framework for building trading strategies. You can easily extend the
  framework to build your own custom strategies. Below is an example of a simple strategy that buys when the fast
  moving average crosses above the slow moving average and sells when the fast moving average crosses below the slow
  moving average.

  ```python

  from aiomql import Strategy, ForexSymbol, TimeFrame, Tracker, OrderType, Sessions, Trader, ScalpTrader


  class EMAXOver(Strategy):
      ttf: TimeFrame  # time frame for the strategy
      tcc: int  # how many candles to consider
      fast_ema: int  # fast moving average period
      slow_ema: int  # slow moving average period
      tracker: Tracker  # tracker to keep track of strategy state
      interval: TimeFrame  # intervals to check for entry and exit signals
      timeout: int  # timeout after placing an order in seconds

      
      
      parameters = {'ttf': TimeFrame.H1, 'tcc': 3000, 'fast_ema': 34, 'slow_ema': 55, 'interval': TimeFrame.M15,
                    'timeout': 3 * 60 * 60}

      def __init__(self, *, symbol: ForexSymbol, params: dict | None = None, trader: Trader = None,
                   sessions: Sessions = None, name: str = "EMAXOver"):
          super().__init__(symbol=symbol, params=params, sessions=sessions, name=name)
          self.tracker = Tracker(snooze=self.interval.seconds)
          self.trader = trader or ScalpTrader(symbol=self.symbol)

      async def find_entry(self):
          
          candles = await self.symbol.copy_rates_from_pos(timeframe=self.ttf, start_position=0, count=self.tcc)

          
          candles.ta.ema(length=self.fast_ema, append=True)
          
          candles.ta.ema(length=self.slow_ema, append=True)
          
          candles.rename(**{f"EMA_{self.fast_ema}": "fast_ema", f"EMA_{self.slow_ema}": "slow_ema"}, inplace=True)

          
          
          fas = candles.ta_lib.cross(candles.fast_ema, candles.slow_ema, above=True)
          
          fbs = candles.ta_lib.cross(candles.fast_ema, candles.slow_ema, above=False)

          
          if fas.iloc[-1]:
              self.tracker.update(order_type=OrderType.BUY, snooze=self.timeout)
          elif fbs.iloc[-1]:
              self.tracker.update(order_type=OrderType.SELL, snooze=self.timeout)
          else:
              self.tracker.update(order_type=None, snooze=self.interval.seconds)

      async def trade(self):
          await self.find_entry()
          if self.tracker.order_type is None:
              await self.sleep(secs=self.tracker.snooze)
          else:
              await self.trader.place_trade(order_type=self.tracker.order_type, parameters=self.parameters)
              await self.delay(secs=self.tracker.snooze)
  ```



  Run the tests with pytest

  ```bash
  pytest test
  ```


  see [API Documentation](docs) for more details


  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.


  Feeling generous, like the package or want to see it become a more mature package?

  Consider supporting the project by buying me a coffee.


  [!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/ichingasamuel)


pkgId: 3e9030671e2b00c2b6e42f7ed504b2657b0204e9629aa135f5a1608464dbd168
name: python-aiomqtt
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: The idiomatic asyncio MQTT client, wrapped around paho-mqtt
url: https://github.com/empicano/aiomqtt
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomqtt-2.3.0-1.src.rpm
checksum_type: sha256
description:
  <!-- documentation start -->
  Write code like this:
  **Publish**
  ```python
  async with Client("test.mosquitto.org") as client:
      await client.publish("temperature/outside", payload=28.4)
  ```
  **Subscribe**
  ```python
  async with Client("test.mosquitto.org") as client:
      await client.subscribe("temperature/#")
      async for message in client.messages:
          print(message.payload)
  ```

  - No more callbacks! 👍
  - No more return codes (welcome to the `MqttError`)
  - Graceful disconnection (forget about `on_unsubscribe`, `on_disconnect`, etc.)
  - Supports MQTT versions 5.0, 3.1.1 and 3.1
  - Fully type-hinted
  - Did we mention no more callbacks?

  ```
  pip install aiomqtt
  ```
  The only dependency is [paho-mqtt](https://github.com/eclipse/paho.mqtt.python).
  If you can't wait for the latest version, install directly from GitHub with:
  ```
  pip install git+https://github.com/empicano/aiomqtt
  ```

  Since Python 3.8, the default asyncio event loop is the `ProactorEventLoop`. Said loop [doesn't support the `add_reader` method](https://docs.python.org/3/library/asyncio-platforms.html#windows) that is required by aiomqtt. Please switch to an event loop that supports the `add_reader` method such as the built-in `SelectorEventLoop`:
  ```python

  if sys.platform.lower() == "win32" or os.name.lower() == "nt":
      from asyncio import set_event_loop_policy, WindowsSelectorEventLoopPolicy
      set_event_loop_policy(WindowsSelectorEventLoopPolicy())

  asyncio.run(main())
  ```

  This project is licensed under the [BSD 3-clause License](https://opensource.org/licenses/BSD-3-Clause).
  Note that the underlying paho-mqtt library is dual-licensed. One of the licenses is the [Eclipse Distribution License v1.0](https://www.eclipse.org/org/documents/edl-v10.php), which is almost identical to the BSD 3-clause License. The only differences are:
  - One use of "COPYRIGHT OWNER" (EDL) instead of "COPYRIGHT HOLDER" (BSD)
  - One use of "Eclipse Foundation, Inc." (EDL) instead of "copyright holder" (BSD)

  We're happy about contributions to aiomqtt! 🎉 You can get started by reading [CONTRIBUTING.md](https://github.com/empicano/aiomqtt/blob/main/CONTRIBUTING.md).

  This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Breaking changes will only occur in major `X.0.0` releases.

  See [CHANGELOG.md](https://github.com/empicano/aiomqtt/blob/main/CHANGELOG.md), which follows the principles of [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).


