# packages

pkgId: e917581b8a657356dbd8f89c8c949d00891b171f2aec3a20dd07617d24cc4107
name: python-aiomultiprocess
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: AsyncIO version of the standard multiprocessing module
url: https://pypi.org/project/aiomultiprocess/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomultiprocess-0.9.1-1.src.rpm
checksum_type: sha256
description:
  Take a modern Python codebase to the next level of performance.
  [![version](https://img.shields.io/pypi/v/aiomultiprocess.svg)](https://pypi.org/project/aiomultiprocess)
  [![documentation](https://readthedocs.org/projects/aiosqlite/badge/?version=latest)](https://aiomultiprocess.omnilib.dev)
  [![changelog](https://img.shields.io/badge/change-log-blue)](https://aiomultiprocess.omnilib.dev/en/latest/changelog.html)
  [![license](https://img.shields.io/pypi/l/aiomultiprocess.svg)](https://github.com/omnilib/aiomultiprocess/blob/master/LICENSE)
  [![build status](https://github.com/omnilib/aiomultiprocess/workflows/Build/badge.svg)](https://github.com/omnilib/aiomultiprocess/actions)
  [![code coverage](https://img.shields.io/codecov/c/gh/omnilib/aiomultiprocess)](https://codecov.io/gh/omnilib/aiomultiprocess)
  [![code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  On their own, AsyncIO and multiprocessing are useful, but limited:
  AsyncIO still can't exceed the speed of GIL, and multiprocessing only works on
  one task at a time.  But together, they can fully realize their true potential.
  aiomultiprocess presents a simple interface, while running a full AsyncIO event
  loop on each child process, enabling levels of concurrency never before seen
  in a Python application.  Each child process can execute multiple coroutines
  at once, limited only by the workload and number of cores available.
  Gathering tens of thousands of network requests in seconds is as easy as:
  ```python
  async with Pool() as pool:
      results = await pool.map(<coroutine function>, <items>)
  ```


pkgId: 6a063d551d76c6d4af8d598ebdce127435fccb5276f020375ac45c6dc54b869a
name: python-aiomusiccast
arch: src
version: 0.14.8
epoch: 0
release: 1
summary: Companion library for musiccast devices intended for the Home Assistant integration.
url: https://pypi.org/project/aiomusiccast
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiomusiccast-0.14.8-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  <picture>
    <source srcset="banner-dark.png" media="(prefers-color-scheme: dark)">
    <img src="banner.png">
  </picture>



  [![PyPI Version](https://img.shields.io/pypi/v/aiomusiccast.svg)](https://pypi.org/project/aiomusiccast)
  ![GitHub release (latest by date)](https://img.shields.io/github/v/release/vigonotion/aiomusiccast)
  ![Read the Docs](https://img.shields.io/readthedocs/aiomusiccast)
  [![PyPI License](https://img.shields.io/pypi/l/aiomusiccast.svg)](https://pypi.org/project/aiomusiccast)


  </div>

  <br/>





  * Python 3.8+



  Install it directly into an activated virtual environment:

  ```text
  $ pip install aiomusiccast
  ```

  or add it to your [Poetry](https://poetry.eustace.io/) project:

  ```text
  $ poetry add aiomusiccast
  ```



  After installation, the package can imported:

  ```text
  $ python
  >>> import aiomusiccast
  >>> aiomusiccast.__version__
  ```


pkgId: 5b266480a9aaa11de19d45f5aa6ee1a0a3f035305590ef09d3f6490b0c7407e5
name: python-aionanoleaf
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Async Python package for the Nanoleaf API
url: https://github.com/milanmeu/aionanoleaf
rpm_license: LGPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aionanoleaf-0.2.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/aionanoleaf)](https://pypi.org/project/aionanoleaf/) ![PyPI - Downloads](https://img.shields.io/pypi/dm/aionanoleaf) [![PyPI - License](https://img.shields.io/pypi/l/aionanoleaf?color=blue)](https://github.com/milanmeu/aionanoleaf/blob/main/COPYING)

  An async Python wrapper for the Nanoleaf API.


  ```bash
  pip install aionanoleaf
  ```



  ```python
  from aionanoleaf import Nanoleaf
  ```


  ```python
  from aiohttp import ClientSession
  session = ClientSession()
  ```


  ```python
  from aionanoleaf import Nanoleaf
  light = Nanoleaf(session, "192.168.0.100")
  ```


  ```python
  from aiohttp import ClientSession
  from asyncio import run

  import aionanoleaf

  async def main():
      async with ClientSession() as session:
          nanoleaf = aionanoleaf.Nanoleaf(session, "192.168.0.73")
          try:
              await nanoleaf.authorize()
          except aionanoleaf.Unauthorized as ex:
              print("Not authorizing new tokens:", ex)
              return
          await nanoleaf.turn_on()
          await nanoleaf.get_info()
          print("Brightness:", nanoleaf.brightness)
          await nanoleaf.deauthorize()
  run(main())
  ```


pkgId: 8307e7c0aa18de3bc0e672436ce9203caa4b82e635f6557c762026fa6ce37e86
name: python-aiondata
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: A common data access layer for AI-driven drug discovery.
url: https://www.github.com/aion-labs/aiondata
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiondata-0.7.1-1.src.rpm
checksum_type: sha256
description:
  AionData is a common data access layer designed for AI-driven drug discovery software. It provides a unified interface to access diverse biochemical databases.


pkgId: bc9c9b1d31299adb3888b825c8e9438c2bb9e3e04418851f05651e73957df57d
name: python-aiondemand
arch: src
version: 0.1.0b1
epoch: 0
release: 1
summary: Python SDK for the AIoD metadata catalogue
url: https://pypi.org/project/aiondemand/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiondemand-0.1.0b1-1.src.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![python](https://img.shields.io/badge/Python-3.11-3776AB.svg?style=flat&logo=python&logoColor=white)](https://www.python.org)



  The [AI-on-Demand](https://aiod.eu) (AIOD) platform empowers AI research and innovation for industry and academia.
  At its core if the [metadata catalogue](https://api.aiod.eu) which indexes countless AI resources, such as datasets, papers, and educational material,
  from many different platforms such as [Zenodo](https://www.zenodo.org), [OpenML](https://www.openml.org), and [AIDA](https://https://www.i-aida.org/ai-educational-resources/).
  This package allows you to explore all resources in the metadata catalogue through Python.
  You can also browse the contents of the AI-on-Demand metadata catalogue through the [MyLibrary](https://mylibrary.aiod.eu) service.


  The `aiondemand` package is on [PyPI](https://pypi.org/project/aiondemand/):

  ```bash
  $ pip install aiondemand
  ```

  Tip: install your dependencies in a [virtual environment](https://realpython.com/python-virtual-environments-a-primer/).


  You can directly access endpoints through the Python API, for example to browse datasets:
  ```python
  import aiod

  aiod.datasets.get_list()
  ```
  And results will be returned as a [Pandas](https://pandas.pydata.org/docs/getting_started/overview.html) dataframe (though the `data_format` may be used to get JSON instead):
  ```bash
        platform platform_resource_identifier                    name       date_published                                            same_as  is_accessible_for_free  ...  relevant_link  relevant_resource relevant_to research_area scientific_domain identifier
  0  huggingface       acronym_identification  acronym_identification  2022-03-02T23:29:22  https://huggingface.co/datasets/acronym_identi...                    True  ...             []                 []          []            []                []          1
  ...
  9  huggingface              allegro_reviews         allegro_reviews  2022-03-02T23:29:22    https://huggingface.co/datasets/allegro_reviews                    True  ...             []                 []          []            []                []         10

  [10 rows x 30 columns]
  ```

  You can even query the elastic search endpoints:
  ```python
  aiod.publications.search(search_query="Robotics")
  ```
  ```bash
        platform platform_resource_identifier                                               name date_published                                            same_as is_accessible_for_free  ... relevant_resource relevant_to      research_area  scientific_domain  type  identifier
  0  robotics4eu                         1803  Responsible Robotics &amp; non-tech barriers t...           None  https://www.robotics4eu.eu/publications/respon...                   None  ...                []          []  [other materials]  [other materials]  None           4

  [1 rows x 36 columns]
  ```


  Interested in contributing? Check out the [contributing guidelines](contributing.md).
  By contributing to this project, you agree to abide by our [Code of Conduct](conduct.md).



  The `aiondemand` package is being developed with funding from EU’s Horizon Europe research and innovation program under grant agreement [No. 101070000 (AI4EUROPE)](https://cordis.europa.eu/project/id/101070000).
  Not all contributors need be affiliated with this funding.

  [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter) were used to create the repository structure.


pkgId: 5c8f0bad16e205dbeb1a14b091d7cbb7cfb0af6a196e4d6be93e850378dc59e9
name: python-aionefit-updated
arch: src
version: 0.15
epoch: 0
release: 1
summary: asyncio library for Bosch thermostats
url: https://github.com/spoetnik/aionefit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aionefit-updated-0.15-1.src.rpm
checksum_type: sha256
description:
  aionefit is a Python library to control some Bosch thermostats using the Python asycio framework. This is done with the [Slixmpp](https://slixmpp.readthedocs.io) library.

  As there is no known way to talk directly to the thermostat, all communication has to be routed via cloud servers at Bosch.


  This software is based on code of the following projects:
  - https://github.com/robertklep/nefit-easy-client
  - https://github.com/patvdleer/nefit-client-python


  [source](https://www.domoticz.com/wiki/NefitEasy)

  - Nefit Easy (Netherlands)
  - Junkers Control CT100 (Belgium, Germany)
  - Buderus Logamatic TC100 (Belgium)
  - E.L.M. Touch (France)
  - Worcester Wave (UK)
  - Bosch Control CT‑100 (Other)


pkgId: 5e9a868c797640340d67541df5105e40cd1f3af889c606ee0683d6bacc34fb69
name: python-aionetbox
arch: src
version: 1.7.4
epoch: 0
release: 1
summary: Async netbox library
url: https://github.com/vapor-ware/aionetbox
rpm_license: GNU General Public License v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aionetbox-1.7.4-1.src.rpm
checksum_type: sha256
description:
  An asyncio netbox library that conforms to any running netbox via it's OpenAPI spec



  AIONetbox is distributed as a library intended to be included in other asyncio python projects. It has been developed on python 3.6+ though 3.8 is recommended.

  ```
  pip install aionetbox
  ```



  ```
  from aionetbox import AIONetbox

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

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

  custom_field_sort = await netbox.dcim.dcim_regions_list(cf_sf_id='identifier')
  ```

  Each module and method map to the swagger definition for netbox (`/api/docs`)

  ![](https://imgur.com/Mhs4UHz.png)


pkgId: 6e4676e0831c9f73555ada4482ee9f1bf4abe51cb792ff98f0b12067fbd1bad2
name: python-aionextpay
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: An async library for requesting to the nextpay.org purchase gate way.
url: https://github.com/HadiH2o/AioNextPay
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aionextpay-1.0.8-1.src.rpm
checksum_type: sha256
description:
  This is an async library for requesting to the https://nextpay.org purchase gateway.<br>
  <h3>How to install : </h3>
  <code>pip install aionextpay</code>
  <h3>How to use : </h3>

  First import <code>NextPay</code> from <code>aionextpay</code><br><br>
  <code>from aionextpay import NextPay</code><br><br>
  Then you need to create an instance from NextPay class and pass it's parameters to it  in an async function<br><br>

  <pre>
  from aionextpay import NextPay


  token = 'your_nextpay_token'
  callback_uri = 'yourdomain.ir/verify'

  async def func():
      amount = '10000' # price of your product
      nextpay = NextPay(token, amount, callback_uri)
  </pre>

  Then you need to use purchase function
  <pre>
  from aionextpay import NextPay


  token = 'your_nextpay_token'
  callback_uri = 'yourdomain.ir/verify'

  async def func():
      amount = '10000' # price of your product
      nextpay = NextPay(token, amount, callback_uri)
      trans_id = await nextpay.purchase(order_id)
  </pre>

  Have in mind that <code>purchase</code> function take kwargs parameter. so read the docs.<br>
  If every thing goes good you get a trans_id from that function.<br>
  p.s : you have to create a gateway payment with that trans_id and give it to the client like this:<br>

  <pre>
  from aionextpay import NextPay


  token = 'your_nextpay_token'
  callback_uri = 'yourdomain.ir/verify'

  async def func():
      amount = '10000' # price of your product
      nextpay = NextPay(token, amount, callback_uri)
      trans_id = await nextpay.purchase(order_id)
      link = f"https://nextpay.org/nx/gateway/payment/{trans_id}"
  </pre>

  When your client complete the purchase nextpay will request to the address you gave to <code>callback_uri</code> variable<br>
  When it does verify the purchase in your request handler like this :<br><br>
  <code>await nextpay.verify(trans_id)</code><br><br>
  If everything goes good it will return True otherwise an exception will raise

  You can also refund the payment like this :<br><br>
  <code>await nextpay.refund(trans_id)</code><br><br>
  If everything goes good it will return True otherwise an exception will raise

rpm_license:
[cell repeats an earlier one in this file: 34486 characters]


pkgId: fe5bebc48e4fcc375e28188e42071605e91b452e4079f8bdb06fbe9cd0248851
name: python-aionotify
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Asyncio-powered inotify library
url: https://github.com/rbarrois/aionotify
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aionotify-0.3.1-1.src.rpm
checksum_type: sha256
description:
  ``aionotify`` is a simple, asyncio-based inotify library.
  Its use is quite simple:
      import asyncio
      import aionotify
      
      watcher = aionotify.Watcher()
      watcher.watch(alias='logs', path='/var/log', flags=aionotify.Flags.MODIFY)
      async def work():
          await watcher.setup()
          for _i in range(10):
              
              event = await watcher.get_event()
              print(event)
          watcher.close()
      asyncio.run(work())


pkgId: a4561019fabd9367054146524fe60cf6907b053e0204312eaa0fed2e65c8a81e
name: python-aionotion
arch: src
version: 2024.3.1
epoch: 0
release: 1
summary: A simple Python 3 library for Notion Home Monitoring
url: https://github.com/bachya/aionotion
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aionotion-2024.3.1-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>

  `aionotion` is a Python 3, asyncio-friendly library for interacting with [Notion][notion]
  home monitoring sensors.

  - [Installation](#installation)
  - [Python Versions](#python-versions)
  - [Usage](#usage)
  - [Contributing](#contributing)



  ```bash
  pip install aionotion
  ```



  `aionotion` is currently supported on:

  - Python 3.10
  - Python 3.11
  - Python 3.12



  ```python
  import asyncio

  from aiohttp import ClientSession

  from aionotion import async_get_client_with_credentials


  async def main() -> None:
      """Create the aiohttp session and run the example."""
      client = await async_get_client_with_credentials(
          "<EMAIL>", "<PASSWORD>", session=session
      )

      
      client.user_uuid
      

      
      client.refresh_token
      

      
      systems = await client.system.async_all()
      

      
      system = await client.system.async_get(12345)
      

      
      bridges = await client.bridge.async_all()
      

      
      bridge = await client.bridge.async_get(12345)
      

      
      sensors = await client.sensor.async_all()
      

      
      sensor = await client.sensor.async_get(12345)
      

      
      listeners = await client.listener.async_all()
      

      
      definitions = await client.listener.async_definitions()
      

      
      user_info = await client.user.async_info()
      

      
      user_preferences = await client.user.async_preferences()
      


  asyncio.run(main())
  ```



  During the normal course of operations, `aionotion` will automatically maintain a refresh
  token and use it when needed. At times, you may wish to manage that token yourself (so
  that you can use it later)–`aionotion` provides a few useful capabilities there.



  `aionotion` allows implementers to defining callbacks that get called when a new refresh
  token is generated. These callbacks accept a single string parameter (the refresh
  token):

  ```python
  import asyncio

  from aiohttp import ClientSession

  from aionotion import async_get_client_with_credentials


  async def main() -> None:
      """Create the aiohttp session and run the example."""
      client = await async_get_client_with_credentials(
          "<EMAIL>", "<PASSWORD>", session=session
      )

      def do_somethng_with_refresh_token(refresh_token: str) -> None:
          """Do something interesting."""
          pass

      
      remove_callback = client.add_refresh_token_callback(do_somethng_with_refresh_token)

      
      remove_callback()


  asyncio.run(main())
  ```



  All of previous examples retrieved an authenticated client with
  `async_get_client_with_credentials`. However, implementers may also create an
  authenticated client by providing a previously retrieved user UUID and refresh token:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from aionotion import async_get_client_with_refresh_token


  async def main() -> None:
      """Create the aiohttp session and run the example."""
      async with ClientSession() as session:
          
          client = await async_get_client_with_refresh_token(
              "<USER UUID>", "<REFRESH TOKEN>", session=session
          )

          


  asyncio.run(main())
  ```



  By default, the library creates a new connection to Notion 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`][aiohttp] `ClientSession` can be used for
  connection pooling:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from aionotion import async_get_client_with_credentials


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

          


  asyncio.run(main())
  ```

  Check out the examples, the tests, and the source files themselves for method
  signatures and more examples.



  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 aionotion tests`
  9. Update `README.md` with any new documentation.
  10. Submit a pull request!

  [aiohttp]: https://github.com/aio-libs/aiohttp
  [ci-badge]: https://img.shields.io/github/actions/workflow/status/bachya/aionotion/test.yml
  [ci]: https://github.com/bachya/aionotion/actions
  [codecov-badge]: https://codecov.io/gh/bachya/aionotion/branch/dev/graph/badge.svg
  [codecov]: https://codecov.io/gh/bachya/aionotion
  [contributors]: https://github.com/bachya/aionotion/graphs/contributors
  [fork]: https://github.com/bachya/aionotion/fork
  [issues]: https://github.com/bachya/aionotion/issues
  [license-badge]: https://img.shields.io/pypi/l/aionotion.svg
  [license]: https://github.com/bachya/aionotion/blob/main/LICENSE
  [maintainability-badge]: https://api.codeclimate.com/v1/badges/bd79edca07c8e4529cba/maintainability
  [maintainability]: https://codeclimate.com/github/bachya/aionotion/maintainability
  [new-issue]: https://github.com/bachya/aionotion/issues/new
  [notion]: https://getnotion.com
  [pypi-badge]: https://img.shields.io/pypi/v/aionotion.svg
  [pypi]: https://pypi.python.org/pypi/aionotion
  [version-badge]: https://img.shields.io/pypi/pyversions/aionotion.svg
  [version]: https://pypi.python.org/pypi/aionotion


pkgId: 4feda165e46a6aea4b7971921e689e62f7aed3c5acdd4f715e87fa49d8d26ad5
name: python-aionut
arch: src
version: 4.3.3
epoch: 0
release: 1
summary: Asyncio Network UPS Tools
url: https://github.com/bdraco/aionut
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aionut-4.3.3-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://aionut.readthedocs.io" target="_blank">https://aionut.readthedocs.io </a>


pkgId: f135af821c4b8b37b462f81c3ea2245c01744e77d4ffebfd6545c83ed0528504
name: python-aioodbc
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: ODBC driver for asyncio.
url: https://github.com/aio-libs/aioodbc
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioodbc-0.5.0-1.src.rpm
checksum_type: sha256
description:
  **aioodbc** is a Python 3.7+ module that makes it possible to access ODBC_ databases
  with asyncio_. It relies on the awesome pyodbc_ library and preserves the same look and
  feel. Internally *aioodbc* employs threads to avoid blocking the event loop,
  threads_ are not that as bad as you think!. Other drivers like motor_ use the
  same approach.
  **aioodbc** is fully compatible and tested with uvloop_. Take a look at the test
  suite, all tests are executed with both the default event loop and uvloop_.


pkgId: 1401c2335d82056efb320724af6b90a0b3fd974b95f9488a2e9424e99dd52ff5
name: python-aiookru
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Python ok.ru API wrapper
url: https://github.com/konstantintogoi/aiookru
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiookru-1.0.0-1.src.rpm
checksum_type: sha256
description:
  async python `ok.ru API <https://apiok.ru/>`_ wrapper
  for `REST API <https://apiok.ru/en/dev/methods/rest>`_ methods.


pkgId: 5769761b2bb6b39d0bda9efceb8dadfe32725785ef8c50e670599ec58d0647f7
name: python-aioopenexchangerates
arch: src
version: 0.6.12
epoch: 0
release: 1
summary: Fetch rates from openexchangerates with aiohttp.
url: https://github.com/MartinHjelmare/aioopenexchangerates
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioopenexchangerates-0.6.12-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://aioopenexchangerates.readthedocs.io" target="_blank">https://aioopenexchangerates.readthedocs.io </a>


pkgId: c1be8d0d4f672f3c80ae53f57307fd6044df15a135f28347b492b70a1b9719f5
name: python-aioopenssl
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: TLS-capable transport using OpenSSL for asyncio
url: https://github.com/horazont/aioopenssl
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioopenssl-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Official documentation can be built with sphinx and is available online
  `on our servers <https://docs.zombofant.net/aioopenssl/0.6/>`_.


pkgId: 4c924b55c93c43da7c8c44e979fc946b3757bc5c9c512bac6c1f3db6b183db29
name: python-aiootp
arch: src
version: 0.23.15
epoch: 0
release: 1
url: https://twitter.com/aiootp
rpm_license: AGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiootp-0.23.15-1.src.rpm
checksum_type: sha256
summary:
  a high-level async cryptographic anonymity library to scale, simplify, & automate privacy best practices for secure data & identity processing, communication, & storage.

description:
  ``aiootp`` is a high-level async cryptographic anonymity library to scale, simplify, & automate privacy best practices for secure data & identity processing, communication, & storage.
  It's home to a family of novel online, salt misuse-reuse resistant, tweakable, & fully context committing AEAD ciphers. A 256-byte block-wise stream cipher named ``Chunky2048``. And, a robust 32-byte hybrid block-cipher / stream-cipher called ``Slick256``. The design goals behind this family of ciphers are to be simple & efficient, while achieving modern security notions, wide security margins, & aiming towards incorporating information theoretic undecidability guarantees where possible.
  We hope to give users & applications empowering developer-friendly privacy enhancing tools with strong, biased defaults. In so doing, increase the overall security, privacy, & anonymity in the digital world. Users will find ``aiootp`` to be easy to write, easy to read, & fun.


pkgId: c371cbf9c02d9fd9be688b422dbe64f04e2e2ae773efa10e5a0674a7865ba522
name: python-aiopathlib
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Pathlib support for asyncio
url: https://github.com/waketzheng/aiopathlib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopathlib-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/aiopathlib.svg)](https://pypi.org/project/aiopathlib/)
  [![image](https://img.shields.io/pypi/pyversions/aiopathlib.svg)](https://pypi.org/project/aiopathlib/)
  [![image](https://img.shields.io/pypi/l/aiopathlib.svg)](https://pypi.org/project/aiopathlib/)
  [![image](https://img.shields.io/codecov/c/github/waketzheng/aiopathlib/master.svg)](https://codecov.io/github/waketzheng/aiopathlib?branch=master)
  [![image](https://img.shields.io/badge/code%20style-pep8-green.svg)](https://www.python.org/dev/peps/pep-0008/)
  **aiopathlib** is written in Python, for handling local
  disk files in asyncio applications.
  Base on [aiofiles](https://github.com/Tinche/aiofiles) and just like pathlib, but use await.
  ```py
  with open('filename', 'w') as fp:
      fp.write('My file contents')
  text = await aiopathlib.AsyncPath('filename').read_text()
  print(text)
  'My file contents'
  content = await aiopathlib.AsyncPath(Path('filename')).read_bytes()
  print(content)
  b'My file contents'
  ```
  Asynchronous interface to create folder.
  ```py
  from aiopathlib import AsyncPath
  apath = AsyncPath('dirname/subpath')
  if not await apath.exists():
      await apath.mkdir(parents=True)
  ```


pkgId: 02d33734b506427d975aa8237f224c0d29b374d4d4f2ca4a479d2c2a495ffd4b
name: python-aiopayAPI
arch: src
version: 0.1.5.1
epoch: 0
release: 1
summary: Асинхронный API для работы с платежной системой Payok.io.
url: https://github.com/artizsq/aiopayAPI
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopayAPI-0.1.5.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Важные ссылки</h1>
  <h2 align="center">
    <a href="https://pypi.org/project/aiopayAPI/">PyPi</a>
    <br>
    <a href="https://aiopayapi.readthedocs.io/ru/latest/index.html">Документация</a>
    <br>
    <a href="">GitHub</a>


pkgId: b3393d9f8e3e0cb4fe7419ad7617c9b0ac71b2fec2a1b0ca2b1a8643e98d3610
name: python-aiopayok
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: payok.io asynchronous python wrapper
url: https://github.com/layerqa/aiopayok
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopayok-0.2.1-1.src.rpm
checksum_type: sha256
description:
  [![GitHub issues](https://img.shields.io/github/issues/layerqa/aiopayok?style=for-the-badge)](https://github.com/layerqa/aiopayok/issues)
  [![GitHub license](https://img.shields.io/github/license/layerqa/aiopayok?style=for-the-badge)](https://github.com/layerqa/aiopayok/blob/main/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/aiopayok?style=for-the-badge)](https://pypi.org/project/aiopayok/)


  >payok.io asynchronous python wrapper

  ``` python
  import asyncio

  from aiopayok import Payok


  payok = Payok("API_ID", "API_KEY")


  async def main() -> None:
      print(await payok.get_balance())

  asyncio.run(main())

  ```



  ``` bash
  pip install aiopayok
  ```



  - Check out the docs at https://payok.io/cabinet/documentation/doc_main.php to learn more about PayOk,


pkgId: 78af18ee83c325ed227e968031c411f1be1e486a485083695e41dc63b4b2f0b4
name: python-aiopcli
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: aiopcli
url: https://pypi.org/project/aiopcli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopcli-1.3.0-1.src.rpm
checksum_type: sha256
description:
  ```
  pip install aiopcli
  ```



  ```



  $ aiopcli image push my-image

  {"imageId": "i-0123456789"}

  $ aiopcli servable create --name=my-servable \
      --api-server=i-0123456789 \
      --api-port=80 \
      --liveness-endpoint=/health \
      --readiness-endpoint=/health

  {"servableId": "s-z15uerp3mehdxg33"}

  $ aiopcli env create --tag=test --servable=s-z15uerp3mehdxg33 --server-plan=basic

  $ aiopcli env get test
  $ aiopcli env get 321



  $ aiopcli predict test -Fimage=@invoice.png


  $ aiopcli predict 321 -d'{"inputs": {"array": [0, 4, 8]}}'


  $ aiopcli predict 321 --endpoint=receipt/read -Fimage=@receipt.jpg


  $ aiopcli env logs 321

  $ aiopcli env logs 321 --since=5m

  $ aiopcli env logs 321 --since=1m30s

  $ aiopcli env logs 321 --container=triton-server


  $ aiopcli status


  $ aiopcli delete test


  $ api_image=$(aiopcli image push api-server | jq -r .imageId)
  $ inference_image=$(aiopcli image push inference-server | jq -r .imageId)
  $ aiopcli servable create --name=my-image \
      --api-server=$api_image \
      --inference-server=$inference_image \
      --api-port=8000 \
      --metrics-port=8002 \  # tritonの場合のみ
      --liveness-endpoint=/health \
      --readiness-endpoint=/health/ready
  ```



  基本設定で作成
  ```
  aiopcli create --servable=<servable-id> --server-plan=<basic,standard,gpu_basic>
  ```

  tagを付けて作成
  ```
  aiopcli create --tag=<tag> --servable=<servable-id> --server-plan=<basic,standard,gpu_basic>
  ```

  環境を削除
  ```
  aiopcli delete <tagまたはenv_id>
  ```

  単体envのステータスを確認
  ```
  aiopcli status <tagまたはenv_id>
  ```

  cliで作成したenvのステータスを確認
  ```
  aiopcli status
  ```

  プロフィール（ホスト・APIキー）を設定してコマンドを実行
  ```
  aiopcli --profile=<profile> <command> <arg> ...

  aiopcli -p<profile> <command> <arg> ...
  ```

  host・apikeyをoverrideして実行
  ```
  aiopcli --host=<host> --apikey=<apikey> <command> <arg> ...

  aiopcli --host=<host> -k<apikey> <command> <arg> ...
  ```

  custom docker imageを登録
  ```

  image_id=$(aiopcli image push single-custom:develop | jq -r .imageId)


  aiopcli servable create --name=single-custom \
      --api-server=$image_id \
      --api-port=8000 \
      --liveness-endpoint=/health \
      --readiness-endpoint=/health


  aiopcli servable create --name=double-custom \
    --api-server=API_IMAGE_ID \
    --inference-server=INFERENCE_IMAGE_ID
  ```



  利用可能な環境変数
  ```
  AIOP_CONFIG=~/.aiop
  AIOP_LOG_LEVEL=INFO
  AIOP_PROFILE=stg
  AIOP_HOST=https://aiops.inside.ai
  AIOP_APIKEY=ICMxJ0Z4PTtvbHE/ITd8Njk4RCgjcy5TL0E3b0YwRj83R2hXKTl8WFAiaGdpSU55fH0kd0IsOCJSZ1AwaUJuPVhWdFJvO1B0O09OQDtsOkVtPydKOnRaIUcqIm8ibFghWitiKTlxUVsqQWkkPG9lJFNbNyNrJzRoNTZzaTF7P2djMy9zKTg4JHZNMVEpQlBIayYkQTtRR2luOEIsXj1iO0JzRyJAdzBaVn1HbWNcc0k5X0JUO0tLeC1vdnRnNTVxLEJfbEEmR1lZNl97ZSZALl9FNnxDYSh+Q09WYHxDPEBqeWYhM1BUbDR5YEw0aCh3UlM6TnAxPmMhXzNnZ3YoYQ==
  ```

  設定ファイルフォーマットはtoml。
  デフォルト保存先： `~/.aiop`、`AIOP_CONFIG`環境変数で設定可。
  ```toml

  default = "stg"


  apikey = "ICMxJ0Z4PTtvbHE/ITd8Njk4RCgjcy5TL0E3b0YwRj83R2hXKTl8WFAiaGdpSU55fH0kd0IsOCJSZ1AwaUJuPVhWdFJvO1B0O09OQDtsOkVtPydKOnRaIUcqIm8ibFghWitiKTlxUVsqQWkkPG9lJFNbNyNrJzRoNTZzaTF7P2djMy9zKTg4JHZNMVEpQlBIayYkQTtRR2luOEIsXj1iO0JzRyJAdzBaVn1HbWNcc0k5X0JUO0tLeC1vdnRnNTVxLEJfbEEmR1lZNl97ZSZALl9FNnxDYSh+Q09WYHxDPEBqeWYhM1BUbDR5YEw0aCh3UlM6TnAxPmMhXzNnZ3YoYQ=="


  [profiles.stg]
  log_level = "INFO"

  [profiles.prod]
  apikey = "QDd+VC55cy1tLV4rQXo2bSZ1OXsgOnx0UzUwbDpEUEQ/UXc3cihvPmtBWHBTWj1LT1w+RXY/aCksbCthVUZGdFUzd2d6e1IrRi5zUycxKlp9YFxEdjE0PXNAXEtGVyZhOC14WWtcXXcoWls6OScxJmlkTSwrTDttc0ouIzhFLEZGJ3xFJWhpI3lpeV1iJ24nSjsyICcgRzxEIi95cGF0eU96TmheaWcobEk+RVxGX01ZYz9jfk9cbThIRyUpaXpLdDklJCR5eTVjYzwyb3F6J2pqJEZbckViNG16PHQkK3xqdUtBSjpRY1UoYiQ1MHBHLitYazUzKD52aVddXzYsbA=="
  ```


pkgId: 99f1eca309b3b6c60395d02b7615b53d51cf2c404dbec605e348f02c076509bd
name: python-aiopegelonline
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: Asynchronous library to retrieve data from PEGELONLINE.
url: https://github.com/mib1185/aiopegelonline
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopegelonline-0.0.10-1.src.rpm
checksum_type: sha256
description:
  You like my work?
  <a href="https://www.buymeacoffee.com/mib1185" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="41" width="174"></a>


pkgId: 6e8bd433c48884d4b6696e2ea0996707036551c8e0b2b50556be99978b28757e
name: python-aiopen
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Async file io
url: https://github.com/dynamic-graphics-inc/dgpy-libs/tree/main/libs/aiopen
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopen-0.6.1-1.src.rpm
checksum_type: sha256
description:
  <a href="https://github.com/dynamic-graphics-inc/dgpy-libs">
  <img align="right" src="https://github.com/dynamic-graphics-inc/dgpy-libs/blob/main/docs/images/dgpy_banner.svg?raw=true" alt="drawing" height="120" width="300"/>
  </a>



  [![Wheel](https://img.shields.io/pypi/wheel/aiopen.svg)](https://img.shields.io/pypi/wheel/aiopen.svg)
  [![Version](https://img.shields.io/pypi/v/aiopen.svg)](https://img.shields.io/pypi/v/aiopen.svg)
  [![py_versions](https://img.shields.io/pypi/pyversions/aiopen.svg)](https://img.shields.io/pypi/pyversions/aiopen.svg)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  **Install:** `pip install aiopen`

  Async-open

  **Why not use aiofiles?**

  - Wanted more type annotations
  - aiofiles uses ye ole `@coroutine` decorator -- aiopen uses python3.6+ `async/await`
  - aiopen is a callable module, so you can do:
    - `import aiopen`
    - `async with aiopen('afile.txt', 'w') as f: await f.write('some text!')`
    - `async with aiopen('afile.txt', 'r') as f: content = await f.read()`

  (Big shouts out to the aiofiles people, aiopen is entirely based off of aiofiles)



  Just import it! The module is also callable!

  ```python
  import aiopen

  async with aiopen('afile.txt', 'w') as f:
      await f.write('some text!')

  async with aiopen('afile.txt', 'r') as f:
      content = await f.read()
      print(content)
  ```


pkgId: f440e6fa9601acb66cba79fc4f2f7258fb08e831a2cc8fa4cff83c8f239559b7
name: python-aiopenapi3
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: client and validator for OpenAPI3 3.0, OpenAPI 3.1, Swagger 2.0
url: https://pypi.org/project/aiopenapi3/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopenapi3-0.7.1-1.src.rpm
checksum_type: sha256
description:
  A Python [OpenAPI 3 Specification](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md) client and validator for Python 3.

  [![Test](https://github.com/commonism/aiopenapi3/actions/workflows/codecov.yml/badge.svg?event=push&branch=master)](https://github.com/commonism/aiopenapi3/actions?query=workflow%3ACodecov+event%3Apush+branch%3Amaster)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/commonism/aiopenapi3/master.svg)](https://results.pre-commit.ci/latest/github/commonism/aiopenapi3/master)
  [![Coverage](https://img.shields.io/codecov/c/github/commonism/aiopenapi3)](https://codecov.io/gh/commonism/aiopenapi3)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/aiopenapi3.svg)](https://pypi.org/project/aiopenapi3)
  [![Documentation Status](https://readthedocs.org/projects/aiopenapi3/badge/?version=latest)](https://aiopenapi3.readthedocs.io/en/latest/?badge=latest)


  This project is a fork of [Dorthu/openapi3](https://github.com/Dorthu/openapi3/).


    * implements …
      * Swagger 2.0
      * OpenAPI 3.0.3
      * OpenAPI 3.1.0
    * description document parsing via [pydantic](https://github.com/samuelcolvin/pydantic)
      * recursive schemas (A.a -> A)
    * request body model creation via pydantic
      * pydantic compatible "format"-type coercion (e.g. datetime.interval)
      * additionalProperties (limited to string-to-any dictionaries without properties)
    * response body & header parsing via pydantic
    * blocking and nonblocking (asyncio) interface via [httpx](https://www.python-httpx.org/)
      * SOCKS5 via httpx_socks
    * tests with pytest & [fastapi](https://fastapi.tiangolo.com/)
    * providing access to methods and arguments via the sad smiley ._. interface
    * Plugin Interface/api to modify description documents/requests/responses to adapt to non compliant services
    * YAML type coercion hints for not well formatted description documents
    * Description Document dependency downloads (using the WebLoader)
      * logging
        * `export AIOPENAPI3_LOGGING_HANDLERS=debug` to get /tmp/aiopenapi3-debug.log



  [API Documentation](https://aiopenapi3.readthedocs.io/en/latest/)




  This project includes a test suite, run via ``pytest``.  To run the test suite,
  ensure that you've installed the dependencies and then run ``pytest`` in the root
  of this project.

  ```shell
  PYTHONPATH=. pytest --cov=./ --cov-report=xml .
  ```


pkgId: 19cc449b8cb5c0ff1ef5341a3d642d7bf512d62ef24b58976b7b8a115d8259eb
name: python-aiopg
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Postgres integration with asyncio.
url: https://aiopg.readthedocs.io
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopg-1.4.0-1.src.rpm
checksum_type: sha256
description:
  **aiopg** is a library for accessing a PostgreSQL_ database
  from the asyncio_ (PEP-3156/tulip) framework. It wraps
  asynchronous features of the Psycopg database driver.


pkgId: b359aa12f819ed64d5dbde94ac989aa2e56bae2d2e9a317bf3fc096dd523ddcb
name: python-aiopioneer
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Asyncio Python library for controlling a Pioneer AVR via its API
url: https://github.com/crowbarz/aiopioneer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopioneer-0.7.1-1.src.rpm
checksum_type: sha256
description:
  <!-- markdownlint-disable MD033 MD041 -->


  Python library for controlling a Pioneer AVR via its built-in API.

  Used by the [pioneer_async](https://github.com/crowbarz/ha-pioneer_async) integration for Home Assistant, which was inspired by the [original Pioneer Home Assistant integration](https://www.home-assistant.io/integrations/pioneer/).
  Originally developed and tested on a VSX-930 (Main Zone and HDZone outputs) but has since been [tested on a larger set of models by the community](https://github.com/crowbarz/ha-pioneer_async/issues/20).



  - Implemented in asyncio.
  - Maintains single continuous telnet session to AVR, with automatic reconnect.
  - Eliminates status polling where AVR sends keepalive responses (on port 8102).
  - Auto-detects Zones 1, 2, 3 and HDZONE.
  - Ignore specific zones, for AVRs that report phantom zones.
  - Automatically polls AVR for source names - no longer need to manually code them in your config any more if your AVR supports their retrieval. Can also set source names manually.
  - Queries device parameters: MAC address, software version, model.
  - Ability to set internal parameters to change the API functionality, eg. maximum volume, volume step change delta.
  - Defaults for internal parameters can be changed based on custom profiles based on AVR model.
  - Includes workaround for AVRs with an initial volume set on the Main Zone (eg. VSX-930).
  - Supports AVRs that do not support setting the volume level by emulating using up/down commands (eg. VSX-S510).
  - Command line client for sending commands and testing
  - Supports all listening mode functions
  - Supports all video related functions
  - Supports panel and remote locking
  - Supports most AMP related functions
  - Supports all tone functions
  - Supports most zone power functions
  - Supports all zone input functions
  - Supports all zone volumne and mute functions
  - Supports setting of tuner band and preset
  - Supports setting frequency directly for capable AVRs, and also by stepping the frequency up/down



  There are several types of parameters that modify the library's functionality. These are listed below in order of increasing priority:

  - **Default parameters**: these are the defaults for all of the parameters
  - **Model parameters**: these parameters are determined by the AVR model as detected by the library. Custom profiles for specific AVR models are defined in [`aiopioneer/param.py](https://github.com/crowbarz/aiopioneer/blob/main/aiopioneer/param.py)
  - **User parameters**: these parameters are provided by the user at instantiation, and can also be updated via the `set_user_params` method
  - **System parameters**: these parameters are set by the library at run time

  Where a parameter is specified at more than one level, the higher priority parameter takes precedence. So a user specified parameter will override any value that is determined by the AVR model.

  **NOTE:** YAML syntax is used in the table below. Use Python equivalents (`false` -> `False`, `true` -> `True`, `null` -> `None` etc.) when calling the Python API directly, and JSON syntax if manually specifying via the Home Assistant integration.

  | Name | Type | Default | Description
  | ---- | ---- | ------- | -----------
  | `ignored_zones` | list | `[]` | List of zones to ignore even if they are auto-discovered. Specify Zone IDs as strings: "1", "2", "3" and "Z".
  | `command_delay` | float | `0.1` | Insert a delay between sequential commands that are sent to the AVR. This appears to make the AVR behave more reliably during status polls. Increase this value if debug logging shows that your AVR times out between commands.
  | `max_source_id` | int | `60` | Maximum source ID that the source discovery queries. Reduce this if your AVR returns errors.
  | `max_volume` | int | `185` | Maximum volume for the Main Zone.
  | `max_volume_zonex` | int | `185` | Maximum volume for zones other than the Main Zone.
  | `power_on_volume_bounce` | bool | `false` | On some AVRs (eg. VSX-930) where a power-on is set, the initial volume is not reported by the AVR correctly until a volume change is made. This option enables a workaround that sends a volume up and down command to the AVR on power-on to correct the reported volume without affecting the power-on volume.
  | `volume_step_only` | bool | `false` | On some AVRs (eg. VSX-S510), setting the volume level is not supported natively by the API. This option emulates setting the volume level using volume up and down commands.
  | `ignore_volume_check` | bool | `false` | Don't check volume when determining whether a zone exists on the AVR. Useful for AVRs with an HDZone that passes through audio.
  | `zone_1_sources` | list | `[]` | (>0.4) Customises the available sources for use with Zone 1. Defaults to all available sources.
  | `zone_2_sources` | list | [see source](https://github.com/crowbarz/aiopioneer/blob/dev/aiopioneer/param.py#L61) | Customises the available sources for use with Zone 2 (some AVRs do not support all sources).
  | `zone_3_sources` | list | [see source](https://github.com/crowbarz/aiopioneer/blob/dev/aiopioneer/param.py#L61) | Customises the available sources for use with Zone 3 (some AVRs do not support all sources).
  | `hdzone_sources` | list | [see source](https://github.com/crowbarz/aiopioneer/blob/dev/aiopioneer/param.py#L61) | Customises the available sources for use with HDZone (some AVRs do not support all sources).
  | `hdzone_volume_requirements` | list | `["13", "15", "05", "25"]` | A list of sources that HDZone must be set to for volume control, some AVRs do not support HDZone volume at all (see `ignore_volume_check` above) and some only allow control of certain sources.
  | `amp_speaker_system_modes` | dict | `....` | Customises the names of speaker system modes. Different generations of AVR will name zones slighty differently. For example, the SC-LX57 names speaker system mode `15` as `5.1ch Bi-Amp + ZONE2` however this can also be called `5.2ch Bi-Amp + HDZONE` on newer AVRs.
  | `extra_amp_listening_modes` | dict | [see source](https://github.com/crowbarz/aiopioneer/blob/dev/aiopioneer/const.py#L24) | (>0.5) Additional listening modes that are added to the list of all possible listening modes for the AVR. This list is used to decode the listening mode ID returned by the AVR. See the source for the format for listening mode definition.
  | `enabled_amp_listening_modes` | list | `[]` | (>0.5) A list of listening mode IDs to be made available for selection. If specified, then no listening mode IDs will be included by default. All enabled source names must be unique, and duplicated names are ignored. The additional listening modes must be actually supported by the AVR, and will return an error (usually `E02`) when an unsupported listening mode is selected. This list is predefined for some AVRs, and specifying this parameter manually will override the model specific default disable list.
  | `disabled_amp_listening_modes` | list | `[]` | A list of listening mode IDs to be disabled. Listening mode IDs that are also specified in `enabled_amp_listening_modes` will be disabled. This list is predefined for some AVRs, and specifying this parameter manually will override the model specific default disable list.
  | `video_resolution_modes` | list | `['0', '1', '3', '4', '5', '6', '7', '8', '9']` | Sets the available video resolutions. Not all AVRs support the same resolution settings. This defaults to all of the latest resolutions from FY16.
  | `mhl_source` | string | `null` | Sets the MHL source ID. This is used for media controls. This information cannot be queried automatically
  | `enabled_functions` | list | `["amp", "dsp", "tuner", "tone", "channels", "video", "system", "audio"]` | Change the functions that are enabled by the API, adding more functions will increase the amount of time it takes to complete a full init and update.
  | `disable_auto_query` | bool | `false` | Setting to `true` will disable auto queries on init for all functions apart from basic functionality (power, source, volume and mute). If you only need those functions, you can set this to `true`
  | `am_frequency_step` | int | `null` | Optional setting to configure the AM frequency step. If this is set to `null`, a function is queued to detect this information by stepping up and down the frequency when the tuner is first used while set to AM.
  | `debug_listener` | bool | `false` | Enables additional debug logging for the listener task.
  | `debug_responder` | bool | `false` | Enables additional debug logging for the responder task.
  | `debug_updater` | bool | `false` | Enables additional debug logging for the updater task.
  | `debug_command` | bool | `false` | Enables additional debug logging for commands sent and responses received.

  If your model of AVR always needs specific parameters to be set for the library to function properly, then please create a PR to add a custom profile for the AVR model.



  The library exposes a Python API through the **PioneerAVR** class. The class methods are listed below:



  `PioneerAVR.__init__(`_host_, _port_ = DEFAULT_PORT, _timeout_: **float** = DEFAULT_TIMEOUT, _scan_interval_: **int** = DEFAULT_SCAN_INTERVAL, _params_: **dict[str, str]** = **None** `)`

  Constructor for the **PioneerAVR** class. The connection parameters are used when `PioneerAVR.connect` is called. After connection is established, the AVR will be polled every _scan_interval_ seconds. Optional user parameters are provided via _params_.

  _awaitable_ `PioneerAVR.connect(`_reconnect_: **bool** = True`)`

  Establish a connection to the AVR. Set _reconnect_ to **True** to attempt to re-establish the connection on disconnect.

  _awaitable_ `PioneerAVR.disconnect()`

  Disconnect from the AVR. Attempt to re-establish the connection if enabled.

  _awaitable_ `PioneerAVR.shutdown()`

  Permanently disconnect from the AVR. Does not attempt reconnection.

  _awaitable_ `PioneerAVR.set_timeout(`_timeout_: **float**`)`

  Set command timeout. Used also to set the socket keepalive timeout.



  _awaitable_ `PioneerAVR.update(`_full_: **bool** = **False**, _wait_: **bool** = **True**`)`

  Request an update of the AVR, and wait for the update to complete if _wait_ is **True**. <br/>
  If _full_ is **True**, then a full update is performed irrespective of when the previous update was performed. Otherwise, an update is performed if the scan interval has elapsed. <br/>
  If a scan interval is set, then an update is scheduled in the updater task. Otherwise the update is performed synchronously (_wait_ cannot be set to **False** in this case).

  _awaitable_ `PioneerAVR.set_scan_interval(`_scan_interval_: **int**`)`

  Set the scan interval to _scan_interval_ and restart the updater task.

  _awaitable_ `PioneerAVR.update_zones()`

  Update zones from `ignored_zones` parameter and re-query zones from the AVR.



  _awaitable_ `PioneerAVR.turn_on(`_zone_: Zones = Zones.Z1`)`:

  Turn on the Pioneer AVR zone.

  _awaitable_ `PioneerAVR.turn_off(`_zone_: Zones = Zones.Z1`)`:

  Turn off the Pioneer AVR zone.

  _awaitable_ `PioneerAVR.query_device_info()`

  Query the AVR for device information. Updates the model parameters if device model is changed.

  _awaitable_ `PioneerAVR.query_zones(`_force_update_: **bool** = **True**`)`

  Query the AVR for available zones by querying the power status for each zone and checking if the AVR responds.
  Ignores zones listed in the `ignored_zones` parameter. <br/>
  If the `ignore_volume_check` parameter is not set, then additionally query the zone volume as well.

  _awaitable_ `PioneerAVR.set_panel_lock(`_panel_lock_: **str**`)`:

  Set the panel lock.

  _awaitable_ `PioneerAVR.set_remote_lock(`_remote_lock_: **bool**`)`:

  Set the remote lock.

  _awaitable_ `PioneerAVR.set_dimmer(`_dimmer_: **str**, _zone_: Zones = Zones.Z1`)`:

  Set the display dimmer.



  _awaitable_ `PioneerAVR.select_source(`_source_: **str** = **None**, _source_id_: **str** = **None**, _zone_: Zones = Zones.Z1`)`:

  Set the input source for _zone_ to name _source_name_ or ID _source_id_ (requires one argument.)

  _awaitable_ `PioneerAVR.build_source_dict()`

  Query the available sources names from the AVR. <br/>
  Parameter `max_source_id` determines the highest source ID that is queried.

  `PioneerAVR.set_source_dict(`_sources_: **dict**[**str**, **str**]`)`

  Manually set the available sources to the dict _sources_, where the keys are source IDs (padded to 2 chars) and the values are the corresponding source names.

  `PioneerAVR.get_source_list(`_zone_: Zones = Zones.Z1`)` -> **list**[**str**]

  Return the set of currently available source names for _zone_. The source names can be used with the `select_source` method.

  `PioneerAVR.get_source_dict(`_zone_: Zones = **None**`)` -> **dict**[**str**, **str**]

  Return a dict of currently available source names to source ID mappings for _zone_. <br/>
  If _zone_ is **None**, then return the dict of all available source names to source ID mappings.

  `PioneerAVR.get_source_name(`_source_id_: **str**`)` -> **str**

  Return the source name for _source_id_.

  _awaitable_ `PioneerAVR.set_source_name(`_source_id_: **str**, _source_name_: **str** = "", _default_: **bool** = **False**`)` -> **bool**

  Renames _source_id_ to _source_name_ on the AVR. <br/>
  If _default_ is **True**, reset _source_id_ to the default source name.

  `PioneerAVR.clear_source_id(`_source_id_: **str**`)`

  Clear the name mapping for _source_id_.



  _awaitable_ `PioneerAVR.send_command(`_command_: **str**, _zone_: Zones = Zones.Z1, _prefix_: **str** = "", _suffix_: **str** = "", _ignore_erro* = **None**, _rate_limit_: **bool** = **True**`)` -> **bool** | **None**

  Send command _command_ for zone _zone_ to the AVR, prefixed with _prefix_ and/or suffixed with _suffix_ if specified. <br/>
  If _command_ does not generate a response, then returns **True** if the command was successfully sent.
  Otherwise, returns the response received from the AVR, **None** if timed out, or **False** if an error response was received. <br/>
  If _ignore_error_ is **None** (default), then raise an exception on error. If _ignore_error_ is **True**, then log the error as level debug, otherwise log the error as level error. <br/>
  Raises `AVRResponseTimeoutError` on timeout, and `AVRCommandError` if the request returned an error.<br/>
  If _rate_limit_ is **True**, then rate limit the commands sent to the AVR in accordance with the `command_delay` parameter.

  `PioneerAVR.queue_command(`_command_: **str**, _skip_if_queued_: **bool** = **True**, _insert_at_: **int** = -1`)` -> **None**

  Add _command_ to the command queue, to to be sent in the background to the AVR when method `command_queue_schedule` is invoked.
  Insert the command at queue position _insert_at_ if specified (inserts at end of the queue by default).

  _awaitable_ `PioneerAVR.send_raw_command(`_command_: **str**, _rate_limit_: **bool** = True`)`

  Send a raw command _command_ to the AVR.
  If _rate_limit_ is **True**, then rate limit the commands sent to the AVR in accordance with the `command_delay` parameter.

  _awaitable_ `PioneerAVR.send_raw_request(`_command_: **str**, _response_prefix_: **str**, _rate_limit_: **bool** = **True**`)` -> **str** | **bool** | **None**

  Send a raw command _command_ to the AVR and wait for a response with prefix _response_prefix_.
  Returns the response received from the AVR.<br/>
  Raises `AVRResponseTimeoutError` on timeout, and `AVRCommandError` if the request returned an error.<br/>
  If _rate_limit_ is **True**, then rate limit the commands sent to the AVR in accordance with the `command_delay` parameter.



  _awaitable_ `PioneerAVR.select_tuner_band(`_band_: TunerBand = TunerBand.FM`)` -> **bool**

  Set the tuner band to _band_.

  _awaitable_ `PioneerAVR.set_tuner_frequency(`_band_: TunerBand, _frequency_: **float** = **None**`)` -> **bool**

  Set the tuner band to _band_ and tuner frequency to _frequency_.
  Step the frequency up or down if it cannot be set directly.

  _awaitable_ `PioneerAVR.select_tuner_preset(`_tuner_class_: **str**, _preset_: **int**`)` -> **bool**:

  Select the tuner preset _preset_ in class _tuner_class_.

  _awaitable_ `PioneerAVR.tuner_previous_preset()`

  Select the previous tuner preset.

  _awaitable_ `PioneerAVR.tuner_next_preset()`

  Select the next tuner preset.



  _awaitable_ `PioneerAVR.select_listening_mode(`_mode_name_: **str** = **None**, _mode_id_: **str** = **None**`)` -> **bool**

  Set the listening mode to name _mode_name_, or ID _mode_id_ (requires one argument.)
  Must be a listening mode valid for the current sound input as returned by `get_listening_modes`.

  `PioneerAVR.get_listening_modes()` -> **dict**[**str**, **str**] | **None**

  Return dict of valid listening mode mapping to names for the AVR.

  _awaitable_ `PioneerAVR.set_volume_level(`_target_volume_: **int**, zone: Zones = Zones.Z1`)`

  Set the volume level for zone _zone_ to _target_volume_.
  _target_volume_ must be between 0 and 185 inclusive for Zone 1, and between 0 and 81 inclusive for all  other zones.

  _awaitable_ `PioneerAVR.mute_on(`_zone_: Zones = Zones.Z1`)` -> **bool**

  Turn mute on for zone _zone_.

  _awaitable_ `PioneerAVR.mute_off(`_zone_: Zones = Zones.Z1`)` -> **bool**

  Turn mute off for zone _zone_.

  _awaitable_ `PioneerAVR.set_tone_settings(`_tone_: **str** = **None**, _treble_: **int** = **None**, _bass_: **int** = **None**, _zone_: Zones = Zones.Z1 `)`*

  Set the tone settings for zone _zone_ to _tone_. When _tone_ is set to `On`, _treble_ specifies the treble and _bass_ specifies the bass.

  _awaitable_ `PioneerAVR.set_amp_settings(`_speaker_config_: **str** = **None**, _hdmi_out_: **str** = **None**, _hdmi_audio_output_: **bool** = **None**, _pqls_: **bool** = **None**, _amp_: **str** = **None**, _zone_: Zones = Zones.Z1`)` -> **bool**

  Set amplifier function settings for zone _zone_.

  `PioneerAVR.get_ipod_control_commands()` -> list[str]

  Return a list of all valid iPod control modes.

  `PioneerAVR.get_tuner_control_commands()` -> list[str]

  Return a list of all valid tuner control commands.

  `PioneerAVR.get_supported_media_controls(`_zone_: Zones`)` -> list[str]

  Return a list of all valid media control actions for zone _zone_.
  Return **None** if the provided zone source is not currently compatible with media controls.

  _awaitable_ `PioneerAVR.set_channel_levels(`_channel_: **str**, _level_: **float**, _zone_: Zones = Zones.Z1`)` -> **bool**

  Set the level (gain) for amplifier channel in zone _zone_.

  _awaitable_ `PioneerAVR.set_video_settings(`_zone_: Zones, **_arguments_`)` -> **bool**

  Set video settings for zone _zone_.

  _awaitable_ `PioneerAVR.set_dsp_settings(`_zone_: Zones, **_arguments_`)` -> **bool**

  Set the DSP settings for the amplifier for zone _zone_.

  _awaitable_ `PioneerAVR.media_control(`_action_: **str**, _zone_: Zones = Zones.Z1`)` -> **bool**

  Perform media control activities such as play, pause, stop, fast forward or rewind.



  `PioneerAVR.set_zone_callback(`_zone_: Zones, _callback_: **Callable**[..., **None**]`)`

  Register callback _callback_ for zone _zone_.

  `PioneerAVR.clear_zone_callbacks()`

  Clear callbacks for all zones.



  `PioneerAVR.set_user_params(`_params_: **dict**[**str**, **Any**] = **None**`)` -> **None**

  Set user parameters and update current parameters.

  `PioneerAVR.get_param(`_param_name_: **str**`)` -> **Any**

  Get the value of the specified parameter.

  `PioneerAVR.get_params()` -> **dict**[**str**, **Any**]

  Get a copy of all current parameters.

  `PioneerAVR.get_user_params()` -> **dict**[**str**, **Any**]

  Get a copy of user parameters.

  `PioneerAVR.get_default_params()` -> **dict**[**str**, **Any**]

  Get a copy of current default parameters.



  Listed below are the public attributes of a `PioneerAVR` object. Use a Zones enum to access zone specific attributes for those that are indexed by zone.

  | Attribute | Type | Description
  | --- | --- | ---
  | `scan_interval` | **int** | Number of seconds between polls for AVR full updates
  | `model` | **str** \| **None** | Model number returned by the AVR
  | `software_version` | **str** \| **None** | Software version returned by the AVR
  | `mac_addr` | **str** \| **None** | System MAC address returned by the AVR
  | `available` | **bool** | Whether integration is connected to the AVR
  | `initial_update` | **bool** \| **None** | Set to **False** if the initial update has been deferred due to the AVR main zone being powered off when initially connected, and **True** when the update has been completed
  | `zones` | **list**[Zones] | List of all zones detected on the AVR
  | `power` | **dict**[Zones, **bool**] | Power status for each detected zone
  | `volume` | **dict**[Zones, **int**] | Volume status for each detected zone
  | `max_volume` | **dict**[Zones, **int**] | Maximum valid volume for each detected zone
  | `mute` | **dict**[Zones, **bool**] | Mute status for each detected zone
  | `source` | **dict**[Zones, **str**] | Active source for each detected zone
  | `listening_mode` | **str** | Name of the currently active listening mode
  | `listening_mode_raw` | **str** | ID of the currently active listening mode
  | `media_control_mode` | **dict**[Zones, **str**] | Media control mode for each detected zone
  | `tone` | | Tone attributes for each detected zone
  | `amp` | | Current AVR amp attributes
  | `tuner` | | Current AVR tuner attributes
  | `channel_levels` | **dict**[**str**, **Any**] | Current AVR channel levels, indexed by channel name
  | `dsp` | | Current AVR DSP attributes
  | `video` | | Current AVR video parameters
  | `audio` | | Current AVR audio parameters
  | `system` | | AVR system attributes



  A very simple command line interface `aiopioneer` is available to connect to the AVR, send commands and receive responses. It can be used to test the capabilities of the library against your specific AVR.

  On Home Assistant, you can run the CLI when the `pioneer_async` Home Assistant integration has been installed. On Home Assistant Supervised or Container, start the CLI from within the HA container: `docker exec -it homeassistant aiopioneer`.

  Invoke the CLI with the following arguments:

  | Argument | Default | Description
  | --- | --- | ---
  | hostname | required | hostname for AVR connection
  | `-p`<br>`--port` | 8102 | port for AVR connection
  | `+Q`<br>`--no-query-device-info` | None | skip AVR device info query
  | `+Z`<br>`--no-query-zones` | None | skip AVR zone query

  The CLI accepts all API commands, as well as the following:

  | Command | Argument | Description
  | --- | --- | ---
  | `exit` or `quit` | | Exit the CLI.
  | `zone` | _zone_ | Change current zone to _zone_.
  | `log_level` | _log_level_ | Change debug level to _log_level_. Valid log levels are: `debug`, `info`, `warning`, `error`, `critical`.
  | `update` | | Request update of AVR. An update is scheduled in the updater task if a scan interval is set, if it is not set then the update is performed synchronously.
  | `update_full` | | Request a full update of AVR irrespective of when the previous update was performed. An update is scheduled in the updater task if a scan interval is set, if it is not set then the update is performed synchronously.
  | `query_device_info` | | Query the AVR for device information.
  | `query_zones` | | Query the AVR for available zones. Ignore zones specified in parameter `ignored_zones` (list).
  | `build_source_dict` | | Query the sources from the AVR.
  | `set_source_dict` | _sources_ (JSON) | Manually set the sources to _sources_.
  | `get_source_list` | | Return the current set of available source names that can be used with the `select_source` command.
  | `get_zone_listening_modes` | | (>0.5) Return the current set of available listening modes.
  | `get_params` | | Return the currently active set of parameters.
  | `get_user_params` | | Return the currently active set of user parameters.
  | `set_user_params` | _params_ (JSON) | Set the user parameters to _params_.
  | `get_tone` | | Returns the current AVR tone attributes.
  | `get_amp` | | Returns the current AVR amp attributes.
  | `get_tuner` | | Returns the current AVR tuner attributes.
  | `get_channel_levels` | | Returns the current AVR channel levels.
  | `get_dsp` | | Returns the current AVR DSP attributes.
  | `get_video` | | Returns the current AVR video parameters.
  | `get_audio` | | Returns the current AVR audio parameters.
  | `get_system` | | Returns the AVR system attributes.
  | `debug_listener` | _state_ (bool) | Enable/disable the `debug_listener` parameter.
  | `debug_responder` | _state_ (bool) | Enable/disable the `debug_responder` parameter.
  | `debug_updater` | _state_ (bool) | Enable/disable the `debug_updater` parameter.
  | `debug_command` | _state_ (bool) | Enable/disable the `debug_command` parameter.
  | `set_scan_interval` | _scan_interval_ (float) | Set the scan interval to _scan_interval_.
  | `get_scan_interval` | | Return the current scan interval.
  | `set_volume_level` | _volume_level_ (int) | Set the volume level for the current zone.
  | `select_source` | _source_name_ | Set the input source for the current zone.
  | `select_listening_mode` | _listening_mode_ | (>0.5) Set the listening mode to the specified mode.
  | `set_tuner_frequency` | _band_ _frequency_ | Set the tuner band and (optionally) frequency.
  | `tuner_previous_preset` | | Select the previous tuner preset
  | `tuner_next_preset` | | Select the next tuner preset
  | `send_raw_command` or `>` | _raw_command_ | Send the raw command _raw_command_ to the AVR.

  **NOTE:** The CLI interface may change in the future, and should not be used in scripts. Use the Python API instead.



  The list below shows the source ID that corresponds to each AVR source:

  | ID | Default Name
  | -- | ---
  | 25 | BD
  | 04 | DVD
  | 06 | SAT/CBL
  | 10 | VIDEO
  | 15 | DVR/BDR
  | 19 | HDMI 1
  | 20 | HDMI 2
  | 21 | HDMI 3
  | 22 | HDMI 4
  | 23 | HDMI 5
  | 24 | HDMI 6
  | 34 | HDMI 7
  | 49 | GAME
  | 26 | NETWORK (cyclic)
  | 38 | INTERNET RADIO
  | 53 | Spotify
  | 41 | PANDORA
  | 44 | MEDIA SERVER
  | 45 | FAVORITES
  | 17 | iPod/USB
  | 05 | TV
  | 01 | CD
  | 13 | USB-DAC
  | 02 | TUNER
  | 00 | PHONO
  | 12 | MULTI CH IN
  | 33 | BT AUDIO
  | 31 | HDMI (cyclic)
  | 46 | AirPlay (Information only)
  | 47 | DMR (Information only)





  - Most PioneerAVR methods now raise exceptions derived from `PioneerError` when an error is encountered, rather than returning `false`, `None` or similar error value. Some instances that currently raise `ValueError` or `SystemError` will also raise `PioneerError` subclasses in the near future
  - `send_raw_request` no longer accepts an argument `ignore_error` and will always raise exceptions on error. Use `ignore_error` with `send_command` to have exceptions handled for you
  - asyncio yields have been optimised and minimised, which may cause certain sequences of operations to happen in a different order



  - Python requirement bumped to 3.11 for `StrEnum`
  - `Zones` enum now used on all methods accepting zone arguments (except in params)
  - Zone argument removed from tuner methods as tuner is independent of zone
  - `TunerBand` enum now used to specify a tuner band
  - `update` now waits for the update to finish by default
  - `set_tuner_preset` has been renamed to `select_tuner_preset`
  - `get_zone_listening_modes` has been renamed to `get_listening_modes`
  - `set_listening_mode` has been renamed to `select_listening_mode`
  - `tuner_*`, `get_zone_listening_modes`, `set_panel_lock`, `set_remote_lock` and `set_dimmer` methods no longer accept a zone argument
  - The `suffix` argument of the `send_command` method has been reordered after the `prefix` argument
  - Response codes marked `---` now return **None**
  - Dimmer mode, tone mode and dB strings have been updated



  - `get_sound_modes` was renamed to `get_zone_listening_modes` to reflect Pioneer AVR terminology
  - `disable_autoquery` was renamed `disable_auto_query` to better match the underlying variable name
  - `amplifier_speaker_system_modes` and `disabled_amplifier_listening_modes` were shortened to `amp_speaker_system_modes` and `disabled_amp_listening_modes` respectively



  - `zone_z_sources` was renamed `hdzone_sources` for even more consistency



  - `zone_h_sources` was renamed `zone_z_sources` for consistency



  - `volume_step_delta` has been removed entirely
  - By default, a number of additional queries are sent at module startup to the AVR to gather amp, tuner and channel levels attributes. If your AVR does not handle these additional queries well, they can be disabled by setting parameter `disable_autoquery` to `true`



  - `_PioneerAVR.__init__()` no longer accepts `command_delay`, `volume_workaround` and `volume_steps` arguments. Configure these parameters using the equivalent `PARAM_*` keys in the `params` dict, passed in via the constructure or set via `set_user_params()`



  - Home Assistant Pioneer integration: [https://www.home-assistant.io/integrations/pioneer/](https://www.home-assistant.io/integrations/pioneer/)
  - Pioneer commands references: [https://github.com/rwifall/pioneer-receiver-notes](https://github.com/rwifall/pioneer-receiver-notes)
  - Another asyncio Pioneer HA component: [https://github.com/realthk/asyncpioneer](https://github.com/realthk/asyncpioneer)
  - Pioneer IP and serial IO control documentation: [https://www.pioneerelectronics.com/PUSA/Support/Home-Entertainment-Custom-Install/RS-232+&+IP+Codes/A+V+Receivers](https://www.pioneerelectronics.com/PUSA/Support/Home-Entertainment-Custom-Install/RS-232+&+IP+Codes/A+V+Receivers)
    - This library supports many of the commands listed in the **2015 Pioneer & Elite AVR External Command** document


pkgId: f3492f1ccb48072323ad8229b6f1ac1739a05df9010d0d1a52a3b5498a29dec5
name: python-aiopipe
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Multiprocess communication pipes for asyncio
url: https://github.com/kchmck/aiopipe
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopipe-0.2.2-1.src.rpm
checksum_type: sha256
description:
  [![Documentation](https://img.shields.io/badge/documentation-blue.svg)](https://kchmck.github.io/aiopipe/aiopipe/)
  [![Build status](https://img.shields.io/circleci/project/github/kchmck/aiopipe/master.svg)](https://circleci.com/gh/kchmck/aiopipe)

  This package wraps the [`os.pipe`](https://docs.python.org/3/library/os.html#os.pipe)
  simplex communication pipe so it can be used as part of the non-blocking
  [`asyncio`](https://docs.python.org/3/library/asyncio.html) event loop. A duplex pipe
  is also provided, which allows reading and writing on both ends.



  The following example opens a pipe with the write end in the child process and the read
  end in the parent process.

  ```python
  >>> from multiprocessing import Process
  >>> import asyncio
  >>>
  >>> from aiopipe import aiopipe
  >>>
  >>> async def main():
  ...     rx, tx = aiopipe()
  ...
  ...     with tx.detach() as tx:
  ...         proc = Process(target=childproc, args=(tx,))
  ...         proc.start()
  ...
  ...     # The write end is now available in the child process
  ...     # and detached from the parent process.
  ...
  ...     async with rx.open() as rx:
  ...         msg = await rx.readline()
  ...
  ...     proc.join()
  ...     return msg
  >>>
  >>> def childproc(tx):
  ...     asyncio.run(childtask(tx))
  >>>
  >>> async def childtask(tx):
  ...     async with tx.open() as tx:
  ...         tx.write(b"hi from the child process\n")
  >>>
  >>> asyncio.run(main())
  b'hi from the child process\n'
  >>>
  ```



  The following example shows a parent and child process sharing a duplex pipe to exchange
  messages.

  ```python
  >>> from multiprocessing import Process
  >>> import asyncio
  >>>
  >>> from aiopipe import aioduplex
  >>>
  >>> async def main():
  ...     mainpipe, chpipe = aioduplex()
  ...
  ...     with chpipe.detach() as chpipe:
  ...         proc = Process(target=childproc, args=(chpipe,))
  ...         proc.start()
  ...
  ...     # The second pipe is now available in the child process
  ...     # and detached from the parent process.
  ...
  ...     async with mainpipe.open() as (rx, tx):
  ...         req = await rx.read(5)
  ...         tx.write(req + b" world\n")
  ...         msg = await rx.readline()
  ...
  ...     proc.join()
  ...     return msg
  >>>
  >>> def childproc(pipe):
  ...     asyncio.run(childtask(pipe))
  >>>
  >>> async def childtask(pipe):
  ...     async with pipe.open() as (rx, tx):
  ...         tx.write(b"hello")
  ...         rep = await rx.readline()
  ...         tx.write(rep.upper())
  >>>
  >>> asyncio.run(main())
  b'HELLO WORLD\n'
  >>>
  ```



  This package requires Python 3.7+ and can be installed with `pip`:
  ```
  pip install aiopipe
  ```


pkgId: 23d28e937daa1aa5e4e4295678639e12727bea04a91e738d44d045b7168d7494
name: python-aiopokeapi
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: An asynchronous API wrapper for the pokeapi.
url: https://pypi.org/project/aiopokeapi/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopokeapi-0.1.10-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
     <h1 align="center"> AioPokéApi</h1>
     <p align="center"> An Asynchronous API wrapper for the <a href="https://pokeapi.co">PokéApi</a>.
  </p>
  <p align="center">
     <img id="tests" src="https://img.shields.io/github/actions/workflow/status/beastmatser/aiopokeapi/tests.yml?branch=main&label=Tests&logo=github&style=flat-square">
     <img id="pypi-version" src="https://img.shields.io/pypi/v/aiopokeapi?label=Pypi%20version&logo=pypi&logoColor=ffffff&style=flat-square">
     <img id="python-version" src="https://img.shields.io/pypi/pyversions/aiopokeapi?label=Python%20version&logo=python&logoColor=ffffff&style=flat-square">
     <img id="license" src="https://img.shields.io/github/license/beastmatser/aiopokeapi?label=License&style=flat-square">
     <img id="style" src="https://img.shields.io/badge/Code%20style-black-black?style=flat-square">
  </p>
  <p align="center">
     <a href="https://github.com/beastmatser/aiopokeapi/issues/new/choose"> Report issue</a>
     ·
     <a href="https://github.com/beastmatser/aiopokeapi/issues/new/choose"> Request feature</a>
     ·
     <a href="https://github.com/beastmatser/aiopokeapi/fork"> Fork project</a>
  </p>



  - Use of modern Python keywords: `async` and `await`.
  - Every object is fully type hinted.
  - Objects get cached, this increases speed and avoids unnecessary API requests.



  AioPokéApi has a very minimal website, which you can find [here](https://beastmatser.github.io/aiopoke/). It also has some [documentation](https://beastmatser.github.io/aiopoke/docs/).



  ```sh
  pip install aiopokeapi
  ```

  <details>

  <summary>
      ⚙️ <i> Didn't work?</i>
  </summary>

  Depending on your Python installation, you might need to use one of the
  following:

  - Python is not in PATH

    ```sh
    path/to/python.exe -m pip install aiopokeapi
    ```

  - Python is in PATH but pip is not

    ```sh
    python -m pip install aiopokeapi
    ```

  - Unix systems can use pip3/python3 commands

    ```sh
    pip3 install aiopokeapi
    ```

    ```sh
    python3 -m pip install aiopokeapi
    ```

  - Using multiple Python versions

    ```sh
    py -m pip install aiopokeapi
    ```

  </details>



  Aiopoke's goal is to be simple and easy to use:

  ```py
  import asyncio
  import aiopoke

  async def main():
     client = aiopoke.AiopokeClient()

     ability = await client.get_ability(1)
     generation = await ability.generation.fetch()

     await client.close()

  asyncio.run(main())
  ```

  Or even better, using a context manager:

  ```py

  async with aiopoke.AiopokeClient() as client:
     ability = await client.get_ability(1)
     generation = await ability.generation.fetch()
  ```


pkgId: 49b909e41459214765d6a0c70f7e31eb5a39aaabe31d6998c9d343836f8bc9c7
name: python-aioprocessing
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: A Python 3.5+ library that integrates the multiprocessing module with asyncio.
url: https://pypi.org/project/aioprocessing/
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioprocessing-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/dano/aioprocessing/workflows/aioprocessing%20tests/badge.svg?branch=master)](https://github.com/dano/aioprocessing/actions)
  `aioprocessing` provides asynchronous, [`asyncio`](https://docs.python.org/3/library/asyncio.html) compatible, coroutine
  versions of many blocking instance methods on objects in the [`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html)
  library. To use [`dill`](https://pypi.org/project/dill) for universal pickling, install using `pip install aioprocessing[dill]`. Here's an example demonstrating the `aioprocessing` versions of
  `Event`, `Queue`, and `Lock`:
  ```python
  import time
  import asyncio
  import aioprocessing
  def func(queue, event, lock, items):
      """ Demo worker function.
      This worker function runs in its own process, and uses
      normal blocking calls to aioprocessing objects, exactly
      the way you would use oridinary multiprocessing objects.
      """
      with lock:
          event.set()
          for item in items:
              time.sleep(3)
              queue.put(item+5)
      queue.close()
  async def example(queue, event, lock):
      l = [1,2,3,4,5]
      p = aioprocessing.AioProcess(target=func, args=(queue, event, lock, l))
      p.start()
      while True:
          result = await queue.coro_get()
          if result is None:
              break
          print("Got result {}".format(result))
      await p.coro_join()
  async def example2(queue, event, lock):
      await event.coro_wait()
      async with lock:
          await queue.coro_put(78)
          await queue.coro_put(None) # Shut down the worker
  if __name__ == "__main__":
      loop = asyncio.get_event_loop()
      queue = aioprocessing.AioQueue()
      lock = aioprocessing.AioLock()
      event = aioprocessing.AioEvent()
      tasks = [
          asyncio.ensure_future(example(queue, event, lock)),
          asyncio.ensure_future(example2(queue, event, lock)),
      ]
      loop.run_until_complete(asyncio.wait(tasks))
      loop.close()
  ```
  The aioprocessing objects can be used just like their multiprocessing
  equivalents - as they are in `func` above - but they can also be
  seamlessly used inside of `asyncio` coroutines, without ever blocking
  the event loop.


pkgId: eff11b4a283a37b09c82d9f0830524729c315539c252321748c252568ab80f7d
name: python-aiops4b-NTTDataUK
arch: src
version: 0.9
epoch: 0
release: 1
summary: Trend analysis and sales forecast
url: https://pypi.org/project/aiops4b-NTTDataUK/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiops4b-NTTDataUK-0.9-1.src.rpm
checksum_type: sha256
description:
  AIOps4B (AIOps for business) is a framework for business decision making.

  Below is the description of what the framework does...

  **Trend Analysis, Root-cause identification and Predicting the future trends accordingly:**
  AIOps4B performs trend analysis on a given time-series dataset (For e.g, Revenue values by date) with additional related metrics that has impact on the data (For e.g, product ratings, delivery timelines, discounts) to detect past trends with changepoints considering external events (for e.g. weather, seasonality, holidays), internal events (for e.g. marketing campaign).

  Each trend change point (for e.g. from down trend to up trend) will be labeled with its root-cause (for e.g. internal or external event, or some metrics that has impact on the Revenue) The un-known anomolies/events (for e.g. black friday) will need to be detected through manual analysis and then defined as internal/external events to be labeled. Once all past trends are identified/labeled with its root-cause, the future trends can be predicted after providing the related future events.

  **Detailed Root-cause analysis & Recommendations:**

  For each root-cause identified/labeled, it further defines the impact of each event and metrics to the overall trend as percentages (For e.g. the imapct of bad product rating is %25 on the Revenue, etc.) to make recommendations accordingly.

  ** Optimized Recommendations:**

  After recommending that (for e.g. if the future Revenue is down), the reason of the past/future trends was because of an event or metric (for e.g. product reviews), it further make optimized recommendation after finding the real cause the problem (why the product reviews was bad and what to do with it)


  **How it can be used:**

  AIOps4B is designed as pyhton package currently with three API's. The pyhton package can be downloaded from
  https://pypi.org/project/aiops4b-NTTDataUK/

  The package can be wrapped/deployed as REST API and embedded in any application / visualization dashboard in the future. As of now, it is used within a pyhton based dash application to display the results in interactive graphics.

  - **Prediction API **predicts the future trends only and compares the predicted value with actuals on an interactive graph. It returns the graph representation, forecasted trend as a result. The graph can be displayed either on a Dash App or can be embedded into Visualization tools.

  - **Recommendation API** analyzes the past trends and predicts the future trends with its root-causes and labels them on an interactive graph. It returns the graph representation and related recommendations (as what to do with each trend) as a result . The graph can be displayed either on a Dash App or can be embedded into Visualization tools.

  - **Optimization API** analyzes the past trends and predicts the future trends with its root-causes and labels them on an interactive graph. It returns the graph representation and related recommendations (as what to do with each trend) as a result . The graph can be displayed either on a Dash App or can be embedded into Visualization tools.

  **What are the use-cases it can be used in:**
  - **Enrich existing KPI dashboards: **If the dataset is ready for a given KPI with its related metrics that is contributing to the revenue, the REST API's can be called to provide past/future complex trend analysis with each root causes and recommendations to fix the issues.
  - Enrich applications with interactive trend analysis/recommendations - it can be embedded into applications of any sort.
  - Respond to business queries: Integrate with Chatbots, Alexa, etc for business users to ask business questions about KPI's and metrics and get root-causes, recommendations to fix. This can an innovative enabler especially for executive stakeholders to respond to their queries such as "Can we achieve our Revenue targets in the coming quarter"?
  - **End to end Business process analysis/issue mining:** It can be integrated with business processes (such as Order to Cash business process) to analyze the overall health of the Revenue generated and define the root causes and alert if the objective Revenue KPI is not met or will not be met in the coming days/months.

  **Next steps:**
  - Use it in real life projects and improve the existing functionality further.
  - Extend the framework with self-learning. After making recommendations, it will need to analyze the outcomes and optimize itself.


pkgId: 5733d80b9aabf9deb2ff5f71ce97744f9a81906957818585939e988003ccd532
name: python-aiopulse2
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Rollease Acmeda Automate Pulse Hub v2 integration.
url: https://github.com/sillyfrog/aiopulse2
rpm_license: apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopulse2-0.10.0-1.src.rpm
checksum_type: sha256
description:
  This is an updated fork of [aiopulse](https://github.com/atmurray/aiopulse/) for the v2 hub (note: this is _not_ compatible with the v1 hub, use `aiopulse` for that). The protocol implementation uses a combination of WebSockets and a TCP connection using a serial like protocol. See the project wiki page for details.

  Requires Python 3.7 or later and uses asyncio and [websockets](https://pypi.org/project/websockets/).

  It has been primarily developed as an integration for [Home Assistant](https://www.home-assistant.io/), using the [Automate Pulse v2](https://github.com/sillyfrog/Automate-Pulse-v2/) integration.



  Run `pip install aiopulse2`.



  This is an interactive interface to test the integration. The available commands are listed below.

  Use the `list` command to get the id of the hubs/blinds.

  | Command                              | Description                                                                                                        |
  | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------ |
  | connect [hub ip][hub ip]...]         | Connect to the hub at ip(s)                                                                                        |
  | disconnect                           | Disconnect all hubs                                                                                                |
  | list                                 | List currently connected hubs and their blinds, use to get the [hub id] and [blind id] for the following commands. |
  | open [hub id][blind id]              | Open blind                                                                                                         |
  | close [hub id][blind id]             | Close blind                                                                                                        |
  | stop [hub id][blind id]              | Stop blind                                                                                                         |
  | moveto [hub id][blind id] [% closed] | Open blind to percentage                                                                                           |
  | exit                                 | Exit program                                                                                                       |



  This is a trivial work-in-progress aiopulse2 command-line-interface wrapper.  It issues a command to a blind given the hub ip address, device name as defined in the *Pulse 2* app and desired percentage closed.  It then waits for the command to complete.

  `python3 pulse_hub_cli.py '192.168.1.127' 'Office 1 of 3' 100`



  This is an example application of pulse_hub_cli.py.  It closes three blinds in sequence.  In this case, it is useful to close the blinds one at a time because they share a small power supply.

  ```
  python3 pulse_hub_cli.py '192.168.1.127' 'Office 1 of 3' 100
  python3 pulse_hub_cli.py '192.168.1.127' 'Office 2 of 3' 100
  python3 pulse_hub_cli.py '192.168.1.127' 'Office 3 of 3' 100
  ```


pkgId: 538558adcbd24fbfd286a5a016f4688239fa127de9cb160231ccbbb89a310888
name: python-aiopurpleair
arch: src
version: 2023.12.0
epoch: 0
release: 1
summary: A Python 3, asyncio-based library to interact with the PurpleAir API
url: https://github.com/bachya/aiopurpleair
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopurpleair-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>

  `aiopurpleair` is a Python3, asyncio-based library to interact with the
  [PurpleAir](https://www2.purpleair.com/) API.

  - [Installation](#installation)
  - [Python Versions](#python-versions)
  - [Usage](#usage)
    - [Checking an API Key](#checking-an-api-key)
    - [Getting Sensors](#getting-sensors)
    - [Getting a Single Sensor](#getting-a-single-sensor)
    - [Getting Nearby Sensors](#getting-nearby-sensors)
    - [Getting a Map URL](#getting-a-map-url)
    - [Connection Pooling](#connection-pooling)
  - [Contributing](#contributing)



  ```bash
  pip install aiopurpleair
  ```



  `aiopurpleair` is currently supported on:

  - Python 3.10
  - Python 3.11
  - Python 3.12



  In-depth documentation on the API can be found [here][purpleair-api]. Unless otherwise
  noted, `aiopurpleair` endeavors to follow the API as closely as possible.



  To check whether an API key is valid and what properties it has:

  ```python
  import asyncio

  from aiopurpleair import API


  async def main() -> None:
      """Run."""
      api = API("<API KEY>")
      response = await api.async_check_api_key()
      
      
      


  asyncio.run(main())
  ```



  ```python
  import asyncio

  from aiopurpleair import API


  async def main() -> None:
      """Run."""
      api = API("<API_KEY>")
      response = await api.sensors.async_get_sensors(["name"])
      
      
      
      
      
      
      
      
      
      


  asyncio.run(main())
  ```



  - `fields` (required): The sensor data fields to include
  - `location_type` (optional): An LocationType to filter by
  - `max_age` (optional): Filter results modified within these seconds
  - `modified_since` (optional): Filter results modified since a UTC datetime
  - `read_keys` (optional): Read keys for private sensors
  - `sensor_indices` (optional): Filter results by sensor index



  ```python
  import asyncio

  from aiopurpleair import API


  async def main() -> None:
      """Run."""
      api = API("<API_KEY>")
      response = await api.sensors.async_get_sensor(131075)
      
      
      
      


  asyncio.run(main())
  ```



  - `sensor_index` (required): The sensor index of the sensor to retrieve.
  - `fields` (optional): The sensor data fields to include.
  - `read_key` (optional): A read key for a private sensor.



  This method returns a list of `NearbySensorResult` objects that are within a bounding box
  around a given latitude/longitude pair. The list is sorted from nearest to furthest
  (i.e., the first index in the list is the closest to the latitude/longitude).

  `NearbySensorResult` objects have two properties:

  - `sensor`: the corresponding `SensorModel` object
  - `distance`: the calculated distance (in kilometers) between this sensor and the provided
    latitude/longitude

  ```python
  import asyncio

  from aiopurpleair import API


  async def main() -> None:
      """Run."""
      api = API("<API_KEY>")
      sensors = await api.sensors.async_get_nearby_sensors(
          ["name"], 51.5285582, -0.2416796, 10
      )
      


  asyncio.run(main())
  ```



  - `fields` (required): The sensor data fields to include
  - `latitude` (required): The latitude of the point to measure distance from
  - `longitude` (required): The longitude of the point to measure distance from
  - `distance` (required): The distance from the measured point to search (in kilometers)
  - `limit` (optional): Limit the results



  If you need to get the URL to a particular sensor index on the PurpleAir map website,
  simply pass the appropriate sensor index to the `get_map_url` method:

  ```python
  import asyncio

  from aiopurpleair import API


  async def main() -> None:
      """Run."""
      api = API("<API_KEY>")
      map_url = api.get_map_url(12345)
      


  asyncio.run(main())
  ```



  By default, the library creates a new connection to the PurpleAir API 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`][aiohttp] `ClientSession` can
  be used for connection pooling:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from aiopurpleair import API


  async def main() -> None:
      """Run."""
      async with ClientSession() as session:
          api = await API("<API KEY>")

          


  asyncio.run(main())
  ```



  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 aiopurpleair tests`
  9. Update `README.md` with any new documentation.
  10. Submit a pull request!

  [aiohttp]: https://github.com/aio-libs/aiohttp
  [ci-badge]: https://github.com/bachya/aiopurpleair/workflows/CI/badge.svg
  [ci]: https://github.com/bachya/aiopurpleair/actions
  [codecov-badge]: https://codecov.io/gh/bachya/aiopurpleair/branch/dev/graph/badge.svg
  [codecov]: https://codecov.io/gh/bachya/aiopurpleair
  [contributors]: https://github.com/bachya/aiopurpleair/graphs/contributors
  [fork]: https://github.com/bachya/aiopurpleair/fork
  [issues]: https://github.com/bachya/aiopurpleair/issues
  [license-badge]: https://img.shields.io/pypi/l/aiopurpleair.svg
  [license]: https://github.com/bachya/aiopurpleair/blob/main/LICENSE
  [maintainability-badge]: https://api.codeclimate.com/v1/badges/40e0f45570a0eb9aab24/maintainability
  [maintainability]: https://codeclimate.com/github/bachya/aiopurpleair/maintainability
  [new-issue]: https://github.com/bachya/aiopurpleair/issues/new
  [new-issue]: https://github.com/bachya/aiopurpleair/issues/new
  [notion]: https://getnotion.com
  [purpleair-api]: https://api.purpleair.com/#api-welcome
  [purpleair]: https://www2.purpleair.com/
  [pypi-badge]: https://img.shields.io/pypi/v/aiopurpleair.svg
  [pypi]: https://pypi.python.org/pypi/aiopurpleair
  [version-badge]: https://img.shields.io/pypi/pyversions/aiopurpleair.svg
  [version]: https://pypi.python.org/pypi/aiopurpleair


pkgId: 50890a419fe6828a69c5c72e780e93fa69e6198f876c363e067803b434e08ef2
name: python-aiopvapi
arch: src
version: 3.1.1
epoch: 0
release: 1
summary: Powerview blinds API wrapper
url: https://github.com/sander76/aio-powerview-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopvapi-3.1.1-1.src.rpm
checksum_type: sha256
description:
  A python asyncio API for PowerView blinds.
  Written for Home-Assistant. Adding features as I go...
  Have a look at the examples folder for some guidance how to use it.


pkgId: 182bd82463d7549fe69f359a09d2e3f869d2dc54501f2324b5905cc77263f697
name: python-aiopvpc
arch: src
version: 4.3.1
epoch: 0
release: 1
summary: Retrieval of Spanish Electricity hourly prices (PVPC)
url: https://github.com/azogue/aiopvpc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopvpc-4.3.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Version][pypi-image]][pypi-url]
  [![pre-commit.ci Status][pre-commit-ci-image]][pre-commit-ci-url]
  [![Build Status][build-image]][build-url]

  <!-- Badges -->

  [pypi-image]: https://img.shields.io/pypi/v/aiopvpc
  [pypi-url]: https://pypi.org/project/aiopvpc/
  [pre-commit-ci-image]: https://results.pre-commit.ci/badge/github/azogue/aiopvpc/master.svg
  [pre-commit-ci-url]: https://results.pre-commit.ci/latest/github/azogue/aiopvpc/master
  [build-image]: https://github.com/azogue/aiopvpc/actions/workflows/main.yml/badge.svg
  [build-url]: https://github.com/azogue/aiopvpc/actions/workflows/main.yml



  Simple aio library to download Spanish electricity hourly prices.

  Made to support the [**`pvpc_hourly_pricing`** HomeAssistant integration](https://www.home-assistant.io/integrations/pvpc_hourly_pricing/).

  <span class="badge-buymeacoffee"><a href="https://www.buymeacoffee.com/azogue" title="Donate to this project using Buy Me A Coffee"><img src="https://img.shields.io/badge/buy%20me%20a%20coffee-donate-yellow.svg" alt="Buy Me A Coffee donate button" /></a></span>



  Install with `pip install aiopvpc` or clone it to run tests or anything else.



  ```python
  import aiohttp
  from datetime import datetime
  from aiopvpc import PVPCData

  async with aiohttp.ClientSession() as session:
      pvpc_handler = PVPCData(session=session, tariff="2.0TD")
      esios_data = await pvpc_handler.async_update_all(
          current_data=None, now=datetime.utcnow()
      )
  print(esios_data.sensors["PVPC"])
  ```


pkgId: 06e450a4b67dc11b015002fcf7a76b1dfbf89a02d8d600f3822500aaaf0e3aef
name: python-aiopyarr
arch: src
version: 23.4.0
epoch: 0
release: 1
summary: An Asynchronous Lidarr, Radarr, Readarr, Sonarr APIs for Python.
url: https://github.com/tkdrob/aiopyarr
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopyarr-23.4.0-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/tkdrob/aiopyarr/branch/master/graph/badge.svg)](https://codecov.io/gh/tkdrob/aiopyarr)
  ![python version](https://img.shields.io/badge/Python-3.9=><=3.10-blue.svg)
  [![PyPI](https://img.shields.io/pypi/v/aiopyarr)](https://pypi.org/project/aiopyarr)
  ![Actions](https://github.com/tkdrob/aiopyarr/workflows/Actions/badge.svg?branch=master)

  _Python API client for Lidarr/Radarr/Readarr/Sonarr._



  ```bash
  python3 -m pip install aiopyarr
  ```



  More examples can be found in the `tests` directory.

  ```python
  """Example usage of aiopyarr."""
  import asyncio
  from aiopyarr.models.host_configuration import PyArrHostConfiguration
  from aiopyarr.radarr_client import RadarrClient

  IP = "192.168.100.3"
  TOKEN = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"


  async def async_example():
      """Example usage of aiopyarr."""
      host_configuration = PyArrHostConfiguration(ipaddress=IP, api_token=TOKEN)
      async with RadarrClient(host_configuration=host_configuration) as client:
          print(await client.async_get_system_status())

  asyncio.get_event_loop().run_until_complete(async_example())
  ```



  **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 `master` branch


pkgId: e0f77ed1ddd3fffd8ebea9069128785d86f356132668fdeecdf10c520e0f7ea1
name: python-aiopygismeteo
arch: src
version: 6.1.0
epoch: 0
release: 1
summary: Asynchronous wrapper for Gismeteo API
url: https://github.com/monosans/aiopygismeteo
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopygismeteo-6.1.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/monosans/aiopygismeteo/actions/workflows/ci.yml/badge.svg)](https://github.com/monosans/aiopygismeteo/actions/workflows/ci.yml)
  [![Downloads](https://static.pepy.tech/badge/aiopygismeteo)](https://pepy.tech/project/aiopygismeteo)

  Асинхронная обёртка для [Gismeteo API](https://gismeteo.ru/api/).

  Синхронная версия [здесь](https://github.com/monosans/pygismeteo).



  Для использования библиотеки нужен API токен, который можно запросить по электронной почте [b2b@gismeteo.ru](mailto:b2b@gismeteo.ru).

  В настоящее время у разработчика отсутствует API токен, что делает невозможными тестирование и дальнейшую разработку.

  Если вам нужна погодная библиотека без API токена, можете рассмотреть <https://github.com/monosans/aiopywttr>.



  ```bash
  python -m pip install -U aiopygismeteo pygismeteo-base
  ```



  <https://aiopygismeteo.readthedocs.io>



  [MIT](https://github.com/monosans/aiopygismeteo/blob/main/LICENSE)


pkgId: 4d6ba4f96adab3abaf0c182d92e2c1dbb50653ca5b666e1ea1a6b6e04099e638
name: python-aiopyramid
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Tools for running pyramid using asyncio.
url: https://github.com/housleyjk/aiopyramid
rpm_license: BSD-derived (http://www.repoze.org/LICENSE.txt)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopyramid-0.4.1-1.src.rpm
checksum_type: sha256
description:
  A library for leveraging pyramid infrastructure asynchronously using the new ``asyncio``.
  ``Aiopyramid`` provides tools for making web applications with ``Pyramid`` and ``asyncio``.
  It will not necessarily make your application run faster. Instead, it gives you some tools
  and patterns to build an application on asynchronous servers.
  Bear in mind that you will need to use asynchronous libraries for io where appropriate.
  Since this library is built on relatively new technology, it is not intended for production use.


pkgId: 8b1ef5227b47afa0f1359379bc6ce2ce8a16115ff1fc8774f19b602cea7bd000
name: python-aiopywttr
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Asynchronous wrapper for wttr.in weather API
url: https://github.com/monosans/aiopywttr
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopywttr-2.3.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/monosans/aiopywttr/actions/workflows/ci.yml/badge.svg)](https://github.com/monosans/aiopywttr/actions/workflows/ci.yml)
  [![Downloads](https://static.pepy.tech/badge/aiopywttr)](https://pepy.tech/project/aiopywttr)

  Asynchronous wrapper for [wttr.in](https://wttr.in) weather API.

  Synchronous version [here](https://github.com/monosans/pywttr).



  ```bash
  python -m pip install -U aiopywttr pywttr-models
  ```



  <https://aiopywttr.readthedocs.io>



  [MIT](https://github.com/monosans/aiopywttr/blob/main/LICENSE)


pkgId: 468c7ade75ccb4aba891c6f038179b7bbe3b4958acc3d60568592a44bd778097
name: python-aiopywttr
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Asynchronous wrapper for wttr.in weather API
url: https://pypi.org/project/aiopywttr/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiopywttr-3.0.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/monosans/aiopywttr/actions/workflows/ci.yml/badge.svg)](https://github.com/monosans/aiopywttr/actions/workflows/ci.yml)
  [![Downloads](https://static.pepy.tech/badge/aiopywttr)](https://pepy.tech/project/aiopywttr)

  Asynchronous wrapper for [wttr.in](https://wttr.in) weather API.

  Synchronous version [here](https://github.com/monosans/pywttr).



  ```bash
  pip install -U aiopywttr pywttr-models
  ```



  <https://aiopywttr.readthedocs.io>



  ```python
  async with aiopywttr.Wttr() as wttr:
      weather = await wttr.weather("Paris", language=aiopywttr.Language.EN)
  print(weather.weather[0].avgtemp_c)
  ```



  [MIT](https://github.com/monosans/aiopywttr/blob/main/LICENSE)


pkgId: 258c39551642de8d1acaa9784ba9c2777bd5f43a6f8f30d463fd37c421e82963
name: python-aioqbt
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: API library for qBittorrent with asyncio
url: https://github.com/tsangwpx/aioqbt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioqbt-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/aioqbt/badge/?version=latest)](https://aioqbt.readthedocs.io/en/latest/?badge=latest)

  Python library for qBittorrent WebAPI with asyncio.

  Features:
  * Async typed interfaces.
  * Complete qBittorrent WebAPI.
  * Tested with qBittorrent v4.1.5 to v5.0.2 on Debian/Ubuntu.



  https://aioqbt.readthedocs.io/en/latest/



  Install with `pip`

  ```shell
  $ pip install aioqbt
  ```

  ```python
  import asyncio

  from aioqbt.api import InfoFilter
  from aioqbt.client import create_client


  async def main():
      client = await create_client(
          "http://localhost:8080/api/v2/",
          username="admin",
          password="adminadmin",
      )

      async with client:
          
          print(await client.app.version())  # v4.6.1
          print(await client.app.webapi_version())  # 2.9.3

          
          for info in await client.torrents.info(filter=InfoFilter.DOWNLOADING):
              print(f"{info.added_on.isoformat()} added {info.name!r}")
              


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

  See [detailed usage on Read the Docs][1].

  [1]: https://aioqbt.readthedocs.io/en/latest/usage.html


pkgId: de06ac9c8d9326e385b5dfcbf933c83a8da2b74c2d14f4479ad02debd1e6a0a4
name: python-aioqsw
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Library to control QNAP QSW devices
url: https://github.com/Noltari/aioqsw
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioqsw-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [![Latest Version][mdversion-button]][md-pypi]
  [![Python Versions][pyversion-button]][md-pypi]
  [![License: Apache 2.0][apache-button]](LICENSE)

  [apache-button]: https://img.shields.io/badge/License-Apache%202.0-blue.svg
  [md-pypi]: https://pypi.org/project/aioqsw
  [mdversion-button]: https://img.shields.io/pypi/v/aioqsw.svg
  [pyversion-button]: https://img.shields.io/pypi/pyversions/aioqsw.svg

  Python library to control QNAP QSW devices.


  - Python >= 3.11


  ```bash
  pip install aioqsw
  ```


  Run the following command inside this folder
  ```bash
  pip install --upgrade .
  ```


  Examples can be found in the `examples` folder


pkgId: aca5d77f7b431c59f82db7937e2afdad11bf8cd25df1ed9504f1faa981b0c4a3
name: python-aioqui
arch: src
version: 2.2.2
epoch: 0
release: 1
summary: Asynchronous GUI framework based on PySide6
url: https://github.com/cxllmerichie/aioqui
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioqui-2.2.2-1.src.rpm
checksum_type: sha256
description:
  ```
  pip install aioqui
  ```

  includes ```pip install pyside6 qasync loguru```

  speedups ```pip install aiodns ujson cchardet uvloop```

  depending on modules [optional] ```pip install aiohttp uvicorn```

rpm_license:
  MIT License  Copyright (c) 2022-2023 cxllmerichie  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.


pkgId: 230b9e3297f16813af9d1f09818692726f6e4f268b075bc5dc15bb6f4b04c9cf
name: python-aioqzone
arch: src
version: 1.8.6.dev1
epoch: 0
release: 1
summary: A Python wrapper for Qzone login and H5 APIs.
url: https://github.com/aioqzone/aioqzone
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioqzone-1.8.6.dev1-1.src.rpm
checksum_type: sha256
description:
  aioqzone封装了一些Qzone接口。

  [![python](https://img.shields.io/pypi/pyversions/aioqzone?logo=python&logoColor=white)][home]
  [![version](https://img.shields.io/pypi/v/aioqzone?logo=python)][pypi]
  [![style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![discuss](https://img.shields.io/badge/dynamic/xml?style=social&logo=telegram&label=Discuss&query=%2F%2Fdiv%5B%40class%3D%22tgme_page_extra%22%5D&url=https%3A%2F%2Ft.me%2Faioqzone_chatroom)](https://t.me/aioqzone_chatroom)

  [English](README_en.md) | 简体中文

  > [!WARNING]
  > aioqzone 仍在开发阶段，任何功能和接口都有可能在未来的版本中发生变化。

  > [!IMPORTANT]
  > **欢迎有意协助开发/维护的中文开发者**。不仅限于本仓库，[aioqzone][org] 所属的任何仓库都需要您的帮助。





  - [x] [二维码登录](src/qqqr/qr/)
  - [x] [密码登录](src/qqqr/up/) (受限)
  - [x] [通过滑动验证码](src/qqqr/up/captcha/slide)
  - [x] [解析图片选择验证码](src/qqqr/up/captcha/select)
  - [ ] [通过网络环境检测][pychaosvm]
  - [x] 爬取HTML说说
  - [x] 爬取说说详细内容
  - [x] 点赞/取消赞
  - [x] 发布(仅文字)/修改/删除说说
  - [x] 发评论



  - [x] 完整的 IDE 类型支持 (typing)
  - [x] API 类型验证 (pydantic)
  - [x] 异步设计
  - [x] 易于二次开发
  - [x] [文档支持](https://aioqzone.github.io/aioqzone)

  __在做了:__

  - [ ] 完善的测试覆盖



  |包名    |简述  |
  |-----------|-------------------|
  |aioqzone   |Qzone API          |
  |qqqr       |Qzone 登录         |



  这些仓库提供了一些 aioqzone 的实际使用示例。



  - [aioqzone-feed][aioqzone-feed]: 提供了操作 feed 的简单接口



  ```
  Copyright (C) 2022-2023 aioqzone.

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU Affero General Public License as published
  by the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Affero General Public License for more details.

  You should have received a copy of the GNU Affero General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  ```

  - aioqzone 以 [AGPL-3.0](LICENSE) 开源.
  - [免责声明](https://aioqzone.github.io/aioqzone/disclaimers.html)


  [home]: https://github.com/aioqzone/aioqzone "Python wrapper for Qzone web login and Qzone http api"
  [aioqzone-feed]: https://github.com/aioqzone/aioqzone-feed "aioqzone plugin providing higher level api for processing feed"
  [pychaosvm]: https://github.com/aioqzone/pychaosvm "A Python envirionment for Tencent ChaosVM."
  [pypi]: https://pypi.org/project/aioqzone
  [org]: https://github.com/aioqzone


pkgId: c042b65a0841c5e337558ddeb7b35caaf9335b779f04c95f4210e7d8428dfb97
name: python-aioqzone
arch: src
version: 1.9.0.dev1
epoch: 0
release: 1
summary: A Python wrapper for Qzone login and H5 APIs.
url: https://github.com/aioqzone/aioqzone
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioqzone-1.9.0.dev1-1.src.rpm
checksum_type: sha256
description:
  aioqzone封装了一些Qzone接口。

  [![python](https://img.shields.io/pypi/pyversions/aioqzone?logo=python&logoColor=white)][home]
  [![version](https://img.shields.io/pypi/v/aioqzone?logo=python)][pypi]
  [![style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![discuss](https://img.shields.io/endpoint?label=Discuss&style=social&url=https%3A%2F%2Ftg.sumanjay.workers.dev%2Faioqzone_chatroom)](https://t.me/aioqzone_chatroom)

  [English](README_en.md) | 简体中文

  > [!WARNING]
  > aioqzone 仍在开发阶段，任何功能和接口都有可能在未来的版本中发生变化。

  > [!IMPORTANT]
  > **欢迎有意协助开发/维护的中文开发者**。不仅限于本仓库，[aioqzone][org] 所属的任何仓库都需要您的帮助。





  - [x] [二维码登录](src/qqqr/qr/)
  - [x] [密码登录](src/qqqr/up/) (受限)
  - [x] [通过滑动验证码](src/qqqr/up/captcha/slide)
  - [x] [解析图片选择验证码](src/qqqr/up/captcha/select)
  - [ ] [通过网络环境检测][pychaosvm]
  - [x] 爬取HTML说说
  - [x] 爬取说说详细内容
  - [x] 点赞/取消赞
  - [x] 发布(仅文字)/修改/删除说说
  - [x] 发评论



  - [x] 完整的 IDE 类型支持 (typing)
  - [x] API 类型验证 (pydantic)
  - [x] 异步设计
  - [x] 易于二次开发
  - [x] [文档支持](https://aioqzone.github.io/aioqzone)

  __在做了:__

  - [ ] 完善的测试覆盖



  |包名    |简述  |
  |-----------|-------------------|
  |aioqzone   |Qzone API          |
  |qqqr       |Qzone 登录         |



  这些仓库提供了一些 aioqzone 的实际使用示例。



  - [aioqzone-feed][aioqzone-feed]: 提供了操作 feed 的简单接口



  ```
  Copyright (C) 2022-2024 aioqzone.

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU Affero General Public License as published
  by the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Affero General Public License for more details.

  You should have received a copy of the GNU Affero General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  ```

  - aioqzone 以 [AGPL-3.0](LICENSE) 开源.
  - [免责声明](https://aioqzone.github.io/aioqzone/disclaimers.html)


  [home]: https://github.com/aioqzone/aioqzone "Python wrapper for Qzone web login and Qzone http api"
  [aioqzone-feed]: https://github.com/aioqzone/aioqzone-feed "aioqzone plugin providing higher level api for processing feed"
  [pychaosvm]: https://github.com/aioqzone/pychaosvm "A Python envirionment for Tencent ChaosVM."
  [pypi]: https://pypi.org/project/aioqzone
  [org]: https://github.com/aioqzone


pkgId: 9f37671572e733f5d5e5ddd0056432bcf34da155c668592786b5c44751a20180
name: python-aioradio
arch: src
version: 0.21.1
epoch: 0
release: 1
url: https://github.com/nrccua/aioradio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioradio-0.21.1-1.src.rpm
checksum_type: sha256
summary:
  Generic asynchronous i/o python utilities for AWS services (SQS, S3, DynamoDB, Secrets Manager), Redis, MSSQL (pyodbc), JIRA and more

description:
  Generic asynchronous i/o python utilities for AWS services (SQS, S3, DynamoDB, Secrets Manager), Redis, MSSQL (pyodbc), JIRA and more.


  aioradio abstracts using aiobotocore and aioboto3 making async AWS funtion calls simple one liners.
  Besides what is shown below in the examples, there is also support for SQS, DynamoDB and Secrets Manager.


  ```python
  import asyncio

  from aioradio.aws.s3 import (
      create_bucket,
      delete_s3_object,
      download_file,
      get_object,
      list_s3_objects,
      upload_file
  )

  async def main():
      s3_bucket = 'aioradio'
      s3_prefix = 'test'
      filename = 'hello_world.txt'
      s3_key = f'{s3_prefix}/{filename}'

      
      await create_bucket(bucket=s3_bucket)

      
      with open(filename, 'w') as file_handle:
          file_handle.write('hello world of aioradio!')

      
      await upload_file(bucket=s3_bucket, filepath=filename, s3_key=s3_key)
      assert s3_key in await list_s3_objects(bucket=s3_bucket, s3_prefix=s3_prefix)

      
      await download_file(bucket=s3_bucket, filepath=filename, s3_key=s3_key)

      
      result = await get_object(bucket=s3_bucket, s3_key=s3_key)
      assert result == b'hello world of aioradio!'

      
      await delete_s3_object(bucket=s3_bucket, s3_prefix=s3_key)
      assert s3_key not in await list_s3_objects(bucket=s3_bucket, s3_prefix=s3_prefix)

  asyncio.get_event_loop().run_until_complete(main())
  ```


  aioredis uses the pyodbc library to work with ODBC databases.
  It currently has support for connecting and sending queries to mssql.

  ```python
  import asyncio

  from aioradio.pyodbc import establish_pyodbc_connection
  from aioradio.pyodbc import pyodbc_query_fetchone
  from aioradio.pyodbc import pyodbc_query_fetchall

  def main():
      conn = establish_pyodbc_connection(host='your-host', user='your-user', pwd='your-password')

      query = "SELECT homeruns FROM MLB.dbo.LosAngelesAngels WHERE lastname = 'Trout' AND year = '2020'"
      row = pyodbc_query_fetchone(conn=conn, query=query)
      print(row)

      query = "SELECT homeruns FROM MLB.dbo.LosAngelesAngels WHERE lastname = 'Trout'"
      rows = pyodbc_query_fetchall(conn=conn, query=query)
      print(rows)


  asyncio.get_event_loop().run_until_complete(main())
  ```


  Jira uses the async library httpx behind the scene to send http requests.

  ```python
  import asyncio

  from aioradio.jira import add_comment_to_jira
  from aioradio.jira import get_jira_issue
  from aioradio.jira import post_jira_issue

  async def main():

      
      url = 'https://aioradio.atlassian.net/rest/api/2/issue/'
      payload = {
          "fields": {
              "project": {"key": "aioradio"},
              "issuetype": {"name": "Task"},
              "reporter": {"accountId": "somebodies-account-id"},
              "priority": {"name": "Medium"},
              "summary": "Aioradio rocks!",
              "description": "Aioradio Review",
              "labels": ["aioradio"],
              "assignee": {"accountId": "somebodies-account-id"}
          }
      }
      resp = await post_jira_issue(url=url, jira_user='your-user', jira_token='your-password', payload=payload)
      jira_id = resp.json()['key']

      
      resp = await get_jira_issue(url=f'{url}/{jira_id}', jira_user='your-user', jira_token='your-password')

      
      comment = 'aioradio rocks!'
      response = await add_comment_to_jira(url=url, jira_user='your-user', jira_token='your-password', comment=comment)

  asyncio.get_event_loop().run_until_complete(main())
  ```



  Install [python 3.11.X](https://www.python.org/downloads/)

  Make sure you've installed [ODBC drivers](https://docs.microsoft.com/en-us/sql/connect/python/pyodbc/step-1-configure-development-environment-for-pyodbc-python-development), required for using the python package pyodbc.

  Clone aioradio locally and navigate to the root directory

  Install and activate python VirtualEnv
  ```bash
  python3.11 -m venv env
  source env/bin/activate
  ```

  Install python modules included in requirements.txt
  ```bash
  pip install cython
  pip install -r aioradio/requirements.txt
  ```

  Run Makefile command from the root directory to test all is good before issuing push to master
  ```
  make all
  ```



  * **Tim Reichard** - [aioradio](https://github.com/nrccua/aioradio)

  See also the list of [contributors](https://github.com/nrccua/aioradio/graphs/contributors) who participated in this project.



  * **Pedro Artiga** - Developer contributing to aioradio.


pkgId: 87338c353123e991fff3d66a5a8486e152f4b28b8cf04059d62ab70dd0eec9d2
name: python-aiorate
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Loop frequency regulator for asyncio.
url: https://pypi.org/project/aiorate/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiorate-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://img.shields.io/github/workflow/status/tasts-robots/aiorate/CI)](https://github.com/tasts-robots/aiorate/actions)
  [![Coverage](https://coveralls.io/repos/github/tasts-robots/aiorate/badge.svg?branch=master)](https://coveralls.io/github/tasts-robots/aiorate?branch=master)
  [![Documentation](https://img.shields.io/badge/docs-online-brightgreen?logo=read-the-docs&style=flat)](https://tasts-robots.org/doc/aiorate/)
  [![PyPI version](https://img.shields.io/pypi/v/aiorate)](https://pypi.org/project/aiorate/)

  Loop frequency regulator for [asyncio](https://docs.python.org/3/library/asyncio.html) with an API similar to [``rospy.Rate``](https://wiki.ros.org/rospy/Overview/Time#Sleeping_and_Rates).

  **This project is archived as it has been superseded by [loop-rate-limiters](https://github.com/stephane-caron/loop-rate-limiters).**



  ```sh
  pip install aiorate
  ```



  The [``Rate``](https://tasts-robots.org/doc/aiorate/rate-limiter.html#aiorate.rate.Rate) class provides a non-blocking loop frequency limiter:

  * Set the loop frequency in Hz at construction: ``rate = aiorate.Rate(200.0)``
  * Call ``await rate.sleep()`` at every loop cycle

  Here is what it looks like in practice:

  ```python
  import asyncio
  import aiorate

  async def main():
      rate = aiorate.Rate(400.0)  # Hz
      while True:
          loop_time = asyncio.get_event_loop().time()
          print(f"Hello from loop at {loop_time:.3f} s")
          await rate.sleep()

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

  Check out the [examples](examples/) folder for more advance use cases, such as multiple loops running simultaneously at different rates.


pkgId: c29d510abeee69036be167923105b5b2ac745b2abba3d51d9419f8088fee1c2a
name: python-aioraven
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Asynchronous communication with Rainforest RAVEn devices.
url: https://github.com/cottsay/aioraven
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioraven-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![build](https://img.shields.io/github/actions/workflow/status/cottsay/aioraven/ci.yaml?branch=main&event=push)](https://github.com/cottsay/aioraven/actions/workflows/ci.yaml?query=branch%3Amain+event%3Apush)
  [![coverage](https://img.shields.io/codecov/c/github/cottsay/aioraven/main)](https://app.codecov.io/gh/cottsay/aioraven/branch/main)
  [![pypi](https://img.shields.io/pypi/v/aioraven)](https://pypi.org/project/aioraven/)
  Asynchronous communication with RAVEn devices made by Rainforest Automation.


pkgId: a9182d91654c47cce2e1072afa05f77a601d67ea2c86a1003fe2b60375f1fbb5
name: python-aiordr
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Simple and fast library for interacting with the o!rdr API.
url: https://github.com/NiceAesth/aiordr
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiordr-0.3.0-1.src.rpm
checksum_type: sha256
description:
  |Python| |pypi| |pre-commit.ci status| |rtd| |pytest| |mypy| |codacy|
  Simple and fast asynchronous library for the o!rdr API.


pkgId: df3d17279f1ce17e43381debbbe86892c6a295ec0b91ce8484bdc410900d9d04
name: python-aioreactive
arch: src
version: 0.20.0
epoch: 0
release: 1
summary: sync/await Reactive Tools for Python 3.10+
url: https://github.com/dbrattli/aioreactive
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioreactive-0.20.0-1.src.rpm
checksum_type: sha256
description:
  <img src="logo/logo.jpg" alt="drawing" width="200"/>



  [![PyPI](https://img.shields.io/pypi/v/aioreactive.svg)](https://pypi.python.org/pypi/aioreactive)
  ![Python package](https://github.com/dbrattli/aioreactive/workflows/Python%20package/badge.svg)
  ![Publish Package](https://github.com/dbrattli/aioreactive/actions/workflows/python-publish.yml/badge.svg)
  [![codecov](https://codecov.io/gh/dbrattli/aioreactive/branch/master/graph/badge.svg)](https://codecov.io/gh/dbrattli/aioreactive)

  > *NEWS: Project rebooted Nov. 2020. Rebuilt using [Expression](https://github.com/dbrattli/Expression).*

  Aioreactive is [RxPY](https://github.com/ReactiveX/RxPY) for asyncio.
  It's an asynchronous and reactive Python library for asyncio using async
  and await. Aioreactive is built on the
  [Expression](https://github.com/dbrattli/Expression) functional library
  and, integrates naturally with the Python language.

  > aioreactive is the unification of RxPY and reactive programming with
  > asyncio using async and await.



  * Python 3.10+ only. We have a hard dependency [Expression v5]([https://www.python.org/dev/peps/pep-0585/](https://github.com/dbrattli/Expression)).
  * All operators and tools are implemented as plain old functions.
  * Everything is `async`. Sending values is async, subscribing to
    observables is async. Disposing subscriptions is async.
  * One scheduler to rule them all. Everything runs on the asyncio base
    event-loop.
  * No multi-threading. Only async and await with concurrency using
    asyncio. Threads are hard, and in many cases it doesn’t make sense to
    use multi-threading in Python applications. If you need to use threads
    you may wrap them with
    [`concurrent.futures`](https://docs.python.org/3/library/concurrent.futures.html#module-concurrent.futures)
    and compose them into the chain with `flat_map()` or similar. See
    [`parallel.py`](https://github.com/dbrattli/aioreactive/blob/master/examples/parallel/parallel.py)
    for an example.
  * Simple, clean and use few abstractions. Try to align with the
    itertools package, and reuse as much from the Python standard library
    as possible.
  * Support type hints and static type checking using [Pylance](https://devblogs.microsoft.com/python/announcing-pylance-fast-feature-rich-language-support-for-python-in-visual-studio-code/).
  * Implicit synchronous back-pressure &trade;. Producers of events will
    simply be awaited until the event can be processed by the down-stream
    consumers.



  With aioreactive you subscribe observers to observables, and the key
  abstractions of aioreactive can be seen in this single line of code:

  ```python
  subscription = await observable.subscribe_async(observer)
  ```

  The difference from RxPY can be seen with the `await` expression.
  Aioreactive is built around the asynchronous duals, or opposites of the
  AsyncIterable and AsyncIterator abstract base classes. These async
  classes are called AsyncObservable and AsyncObserver.

  AsyncObservable is a producer of events. It may be seen as the dual or
  opposite of AsyncIterable and provides a single setter method called
  `subscribe_async()` that is the dual of the `__aiter__()` getter method:

  ```python
  from abc import ABC, abstractmethod

  class AsyncObservable(ABC):
      @abstractmethod
      async def subscribe_async(self, observer):
          return NotImplemented
  ```

  AsyncObserver is a consumer of events and is modeled after the
  so-called [consumer interface](http://effbot.org/zone/consumer.htm), the
  enhanced generator interface in
  [PEP-342](https://www.python.org/dev/peps/pep-0342/) and async
  generators in [PEP-525](https://www.python.org/dev/peps/pep-0525/). It
  is the dual of the AsyncIterator `__anext__()` method, and expands to
  three async methods `asend()`, that is the opposite of `__anext__()`,
  `athrow()` that is the opposite of an `raise Exception()` and `aclose()`
  that is the opposite of `raise StopAsyncIteration`:

  ```python
  from abc import ABC, abstractmethod

  class AsyncObserver(ABC):
      @abstractmethod
      async def asend(self, value):
          return NotImplemented

      @abstractmethod
      async def athrow(self, error):
          return NotImplemented

      @abstractmethod
      async def aclose(self):
          return NotImplemented
  ```



  An observable becomes hot and starts streaming items by using the
  `subscribe_async()` method. The `subscribe_async()` method takes an
  observable and returns a disposable subscription. So the
  `subscribe_async()` method is used to attach a observer to the
  observable.

  ```python
  async def asend(value):
      print(value)

  disposable = await subscribe_async(source, AsyncAnonymousObserver(asend))
  ```

  `AsyncAnonymousObserver` is an anonymous observer that constructs an
  `AsyncObserver` out of plain async functions, so you don't have to
  implement a new named observer every time you need one.

  The subscription returned by `subscribe_async()` is disposable, so to
  unsubscribe you need to await the `dispose_async()` method on the
  subscription.

  ```python
  await subscription.dispose_async()
  ```



  Even more interesting, with `to_async_iterable` you can flip around from
  `AsyncObservable` to an `AsyncIterable` and use `async-for` to consume
  the stream of events.

  ```python
  import aioreactive as rx

  xs = rx.from_iterable([1, 2, 3])
  async for x in xs:
      print(x)
  ```

  They effectively transform us from an async push model to an async pull
  model, and lets us use the awesome new language features such as `async
  for` and `async-with`. We do this without any queueing, as a push by the
  `AsyncObservable` will await the pull by the `AsyncIterator.  This
  effectively applies so-called "back-pressure" up the subscription as the
  producer will await the iterator to pick up the item send.

  The for-loop may be wrapped with async-with to control the lifetime of
  the subscription:

  ```python
  import aioreactive as rx

  xs = rx.from_iterable([1, 2, 3])
  result = []

  obv = rx.AsyncIteratorObserver(xs)
  async with await xs.subscribe_async(obv) as subscription:
      async for x in obv:
          result.append(x)

  assert result == [1, 2, 3]
  ```



  An async stream is both an async observer and an async observable.
  Aioreactive lets you create streams explicitly.

  ```python
  import aioreactive as rx

  stream = AsyncSubject()  # Alias for AsyncMultiStream

  sink = rx.AsyncAnonymousObserver()
  await stream.subscribe_async(sink)
  await stream.asend(42)
  ```

  You can create streams directly from `AsyncMultiStream` or
  `AsyncSingleStream`. `AsyncMultiStream` supports multiple observers, and
  is hot in the sense that it will drop any event that is sent if there
  are currently no observers attached. `AsyncSingleStream` on the other
  hand supports a single observer, and is cold in the sense that it will
  await any producer until there is an observer attached.



  The Rx operators in aioreactive are all plain old functions. You can
  apply them to an observable and compose it into a transformed, filtered,
  aggregated or combined observable. This transformed observable can be
  streamed into an observer.

      Observable -> Operator -> Operator -> Operator -> Observer

  Aioreactive contains many of the same operators as you know from RxPY.
  Our goal is not to implement them all, but to provide the most essential
  ones.

  * **concat** -- Concatenates two or more observables.
  * **choose** -- Filters and/or transforms the observable.
  * **choose_asnc** -- Asynchronously filters and/or transforms the observable.
  * **debounce** -- Throttles an observable.
  * **delay** -- delays the items within an observable.
  * **distinct_until_changed** -- an observable with continuously distinct values.
  * **filter** -- filters an observable.
  * **filteri** -- filters an observable with index.
  * **flat_map** -- transforms an observable into a stream of observables and flattens the resulting observable.
  * **flat_map_latest** -- transforms an observable into a stream of
    observables and flattens the resulting observable by producing values
    from the latest observable.
  * **from_iterable** -- Create an observable from an (async) iterable.
  * **subscribe** -- Subscribes an observer to an observable. Returns a subscription.
  * **map** -- transforms an observable.
  * **mapi** -- transforms an observable with index.
  * **map_async** -- transforms an observable asynchronously.
  * **mapi_async** -- transforms an observable asynchronously with index.
  * **merge_inner** -- Merges an observable of observables.
  * **merge** -- Merge one observable with another observable.
  * **merge_seq** -- Merge a sequence of observables.
  * **run** -- Awaits the future returned by subscribe. Returns when the subscription closes.
  * **slice** -- Slices an observable.
  * **skip** -- Skip items from the start of the observable stream.
  * **skip_last** -- Skip items from the end of the observable stream.
  * **starfilter** -- Filters an observable with a predicate and spreads the arguments.
  * **starmap** -- Transforms and async observable and spreads the arguments to the mapper.
  * **switch_latest** -- Merges the latest stream in an observable of streams.
  * **take** -- Take a number of items from the start of the observable stream.
  * **take_last** -- Take a number of items from the end of the observable stream.
  * **unit** -- Converts a value or future to an observable.
  * **with_latest_from** -- Combines two observables into one.



  With aioreactive you can choose to program functionally with plain old
  functions, or object-oriented with classes and methods. Aioreactive
  supports both method chaining or forward pipe programming styles.



  `AsyncObservable` may compose operators using forward pipelining with
  the `pipe` operator provided by the amazing
  [Expression](https://github.com/dbrattli/Expression) library. This works
  by having the operators partially applied with their arguments before
  being given the source stream as the last curried argument.

  ```python
  ys = pipe(xs, filter(predicate), map(mapper), flat_map(request))
  ```

  Longer pipelines may break lines as for binary operators:

  ```python
  import aioreactve as rx

  async def main():
      stream = rx.AsyncSubject()
      obv = rx.AsyncIteratorObserver()

      xs = pipe(
          stream,
          rx.map(lambda x: x["term"]),
          rx.filter(lambda text: len(text) > 2),
          rx.debounce(0.75),
          rx.distinct_until_changed(),
          rx.map(search_wikipedia),
          rx.switch_latest(),
      )

      async with xs.subscribe_async(obv) as ys
          async for value in obv:
              print(value)
  ```

  AsyncObservable also supports slicing using the Python slice notation.

  ```python
  @pytest.mark.asyncio
  async def test_slice_special():
      xs = rx.from_iterable([1, 2, 3, 4, 5])
      values = []

      async def asend(value):
          values.append(value)

      ys = xs[1:-1]

      result = await run(ys, AsyncAnonymousObserver(asend))

      assert result == 4
      assert values == [2, 3, 4]
  ```



  An alternative to pipelining is to use the classic and fluent method
  chaining as we know from [ReactiveX](http://reactivex.io).

  An `AsyncObservable` created from class methods such as
  `AsyncRx.from_iterable()` returns a `AsyncChainedObservable`.
  where we may use methods such as `.filter()` and `.map()`.

  ```python
  from aioreactive import AsyncRx

  @pytest.mark.asyncio
  async def test_observable_simple_pipe():
      xs = AsyncRx.from_iterable([1, 2, 3])
      result = []

      async def mapper(value):
          await asyncio.sleep(0.1)
          return value * 10

      async def predicate(value):
          await asyncio.sleep(0.1)
          return value > 1

      ys = xs.filter(predicate).map(mapper)

      async def on_next(value):
          result.append(value)

      subscription = await ys.subscribe_async(AsyncAnonymousObserver(on_next))
      await subsubscription
      assert result == [20, 30]
  ```



  Aioreactive also provides a virtual time event loop
  (`VirtualTimeEventLoop`) that enables you to write asyncio unit-tests
  that run in virtual time. Virtual time means that time is emulated, so
  tests run as quickly as possible even if they sleep or awaits long-lived
  operations. A test using virtual time still gives the same result as it
  would have done if it had been run in real-time.

  For example the following test still gives the correct result even if it
  takes 0 seconds to run:

  ```python
  @pytest.fixture()
  def event_loop():
      loop = VirtualTimeEventLoop()
      yield loop
      loop.close()

  @pytest.mark.asyncio
  async def test_call_later():
      result = []

      def action(value):
          result.append(value)

      loop = asyncio.get_event_loop()
      loop.call_later(10, partial(action, 1))
      loop.call_later(1, partial(action, 2))
      loop.call_later(5, partial(action, 3))
      await asyncio.sleep(10)
      assert result == [2, 3, 1]
  ```

  The aioreactive testing module provides a test `AsyncSubject` that may
  delay sending values, and a test `AsyncTestObserver` that records all
  events. These two classes helps you with testing in virtual time.

  ```python
  @pytest.fixture()
  def event_loop():
      loop = VirtualTimeEventLoop()
      yield loop
      loop.close()

  @pytest.mark.asyncio
  async def test_delay_done():
      xs = AsyncTestSubject()  # Test stream

      ys = pipe(xs, rx.delay(1.0))
      obv = AsyncTestObserver()  # Test AsyncAnonymousObserver
      async with await ys.subscribe_async(obv):
          await xs.asend_later(0, 10)
          await xs.asend_later(1.0, 20)
          await xs.aclose_later(1.0)
          await obv

      assert obv.values == [
          (ca(1), OnNext(10)),
          (ca(2), OnNext(20)),
          (ca(3), OnCompleted()),
      ]
  ```



  `AsyncIterable` and `AsyncObservable` are closely related (in fact they
  are duals). `AsyncIterable` is an async iterable (pull) world, while
  `AsyncObservable` is an async reactive (push) based world. There are
  many operations such as `map()` and `filter()` that may be simpler to
  implement using `AsyncIterable`, but once we start to include time, then
  `AsyncObservable` really starts to shine. Operators such as `delay()`
  makes much more sense for `AsyncObservable` than for `AsyncIterable`.

  However, aioreactive makes it easy for you to flip-around to async
  iterable just before you need to consume the stream, thus giving you the
  best of both worlds.



  Aioreactive will not replace [RxPY](https://github.com/ReactiveX/RxPY).
  RxPY is an implementation of `Observable`. Aioreactive is an
  implementation of `AsyncObservable`.

  Rx and RxPY has hundreds of different query operators, and we currently
  have no plans to implementing all of them for aioreactive.

  Many ideas from aioreactive have already been ported back into "classic" RxPY.



  Aioreactive was inspired by:

  * [AsyncRx](https://github.com/dbrattli/asyncrx) - Aioreactive is a direct port of AsyncRx from F#.
  * [Expression](https://github.com/dbrattli/Expression) - Functional programming for Python.
  * [Is it really Pythonic to continue using LINQ operators instead of plain old functions?](https://github.com/ReactiveX/RxPY/issues/94)
  * [Reactive Extensions (Rx)](http://reactivex.io) and [RxPY](https://github.com/ReactiveX/RxPY).
  * [Dart Streams](https://www.dartlang.org/tutorials/language/streams)
  * [Underscore.js](http://underscorejs.org).
  * [itertools](https://docs.python.org/3/library/itertools.html) and [functools](https://docs.python.org/3/library/functools.html).
  * [dbrattli/OSlash](https://github.com/dbrattli/OSlash)
  * [kriskowal/q](https://github.com/kriskowal/q).



  The MIT License (MIT)
  Copyright (c) 2016 Børge Lanes, Dag Brattli.


pkgId: 4a6cbc6d4683b26ee126cfa024b2e24a65dd6d01262265e0c897f9ef03b9fe36
name: python-aiorecollect
arch: src
version: 2023.12.0
epoch: 0
release: 1
summary: A Python 3, asyncio-based library for the ReCollect Waste API
url: https://github.com/bachya/aiorecollect
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiorecollect-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>

  `aiorecollect` is a Python 3, asyncio-based library for the ReCollect Waste API. It allows
  users to programmatically retrieve schedules for waste removal in their area, including
  trash, recycling, compost, and more.

  Special thanks to @stealthhacker for the inspiration!



  ```bash
  pip install aiorecollect
  ```



  `aiorecollect` is currently supported on:

  - Python 3.10
  - Python 3.11
  - Python 3.12



  To use `aiorecollect`, you must know both your ReCollect Place and Service IDs.

  In general, cities/municipalities that utilize ReCollect will give you a way to
  subscribe to a calendar with pickup dates. If you examine the iCal URL for this
  calendar, the Place and Service IDs are embedded in it:

  ```
  webcal://recollect.a.ssl.fastly.net/api/places/PLACE_ID/services/SERVICE_ID/events.en-US.ics
  ```



  ```python
  import asyncio
  from datetime import date

  from aiorecollect import Client


  async def main() -> None:
      """Run."""
      client = await Client("<PLACE ID>", "<SERVICE ID>")

      
      client.place_id
      client.service_id

      
      pickup_events = await client.async_get_pickup_events()

      
      pickup_events = await client.async_get_pickup_events(
          start_date=date(2020, 10, 1), end_date=date(2020, 10, 31)
      )

      
      next_pickup = await client.async_get_next_pickup_event()


  asyncio.run(main())
  ```



  The `PickupEvent` object that is returned from the above calls comes with three
  properties:

  - `date`: a `datetime.date` that denotes the pickup date
  - `pickup_types`: a list of `PickupType` objects that will occur with this event
  - `area_name`: the name of the area in which the event is occurring



  The `PickupType` object contains the "internal" name of the pickup type _and_ a
  human-friendly representation when it exists:

  - `name`: the internal name of the pickup type
  - `friendly_name`: the humany-friendly name of the pickup type (if it exists)



  By default, the library creates a new connection to ReCollect 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`][aiohttp] `ClientSession` can be used for
  connection pooling:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from aiorecollect import Client


  async def main() -> None:
      """Run."""
      async with ClientSession() as session:
          client = await Client("<PLACE ID>", "<SERVICE ID>", session=session)

          


  asyncio.run(main())
  ```



  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 aiorecollect tests`
  9. Update `README.md` with any new documentation.
  10. Submit a pull request!

  [aiohttp]: https://github.com/aio-libs/aiohttp
  [ci-badge]: https://github.com/bachya/aiorecollect/workflows/CI/badge.svg
  [ci]: https://github.com/bachya/aiorecollect/actions
  [codecov-badge]: https://codecov.io/gh/bachya/aiorecollect/branch/dev/graph/badge.svg
  [codecov]: https://codecov.io/gh/bachya/aiorecollect
  [contributors]: https://github.com/bachya/aiorecollect/graphs/contributors
  [fork]: https://github.com/bachya/aiorecollect/fork
  [issues]: https://github.com/bachya/aiorecollect/issues
  [license-badge]: https://img.shields.io/pypi/l/aiorecollect.svg
  [license]: https://github.com/bachya/aiorecollect/blob/main/LICENSE
  [maintainability-badge]: https://api.codeclimate.com/v1/badges/65fe7eb308dca67c1038/maintainability
  [maintainability]: https://codeclimate.com/github/bachya/aiorecollect/maintainability
  [new-issue]: https://github.com/bachya/aiorecollect/issues/new
  [new-issue]: https://github.com/bachya/aiorecollect/issues/new
  [pypi-badge]: https://img.shields.io/pypi/v/aiorecollect.svg
  [pypi]: https://pypi.python.org/pypi/aiorecollect
  [version-badge]: https://img.shields.io/pypi/pyversions/aiorecollect.svg
  [version]: https://pypi.python.org/pypi/aiorecollect


pkgId: e530903f3a60ceac4a19abf7f626f4d71d9b417dfbbf53e19d06c35e15fc0ea6
name: python-aioredis
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: asyncio (PEP 3156) Redis support
url: https://github.com/aio-libs/aioredis-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioredis-2.0.1-1.src.rpm
checksum_type: sha256
description:
  asyncio (3156) Redis client library.

  The library is intended to provide simple and clear interface to Redis
  based on asyncio.



  | Feature                      | Supported                |
  |:-----------------------------|:-------------------------|
  | hiredis parser               | :white_check_mark:       |
  | Pure-python parser           | :white_check_mark:       |
  | Low-level & High-level APIs  | :white_check_mark:       |
  | Pipelining support           | :white_check_mark:       |
  | Multi/Exec support           | :white_check_mark:       |
  | Connections Pool             | :white_check_mark:       |
  | Pub/Sub support              | :white_check_mark:       |
  | Sentinel support             | :white_check_mark:       |
  | ACL support                  | :white_check_mark:       |
  | Streams support              | :white_check_mark:       |
  | Redis Cluster support        | :no_entry_sign:          |
  | Tested Python versions       | 3.6, 3.7, 3.8, 3.9, 3.10 |
  | Tested for Redis servers     | 5.0, 6.0                 |
  | Support for dev Redis server | through low-level API    |




  The easiest way to install aioredis is by using the package on PyPi:

      pip install aioredis

  Recommended with hiredis for performance and stability reasons:

      pip install hiredis



  -   Python 3.6+
  -   hiredis (Optional but recommended)
  -   async-timeout
  -   typing-extensions



  Benchmarks can be found here:
  <https://github.com/popravich/python-redis-benchmark>



  -   Issue Tracker: <https://github.com/aio-libs/aioredis/issues>
  -   Google Group: <https://groups.google.com/g/aio-libs>
  -   Gitter: <https://gitter.im/aio-libs/Lobby>
  -   Source Code: <https://github.com/aio-libs/aioredis>
  -   Contributor's guide: [devel](docs/devel.md)

  Feel free to file an issue or make pull request if you find any bugs or
  have some suggestions for library improvement.



  The aioredis is offered under a [MIT License](LICENSE).







  - Added Python 3.10 to CI & Updated the Docs
    (see #1160)
  - Enable mypy in CI (see #1101)
  - Synchronized reading the responses from a connection
    (see #1106)



  - Remove __del__ from Redis (Fixes #1115)
    (see #1227)
  - fix socket.error raises (see #1129)
  - Fix buffer is closed error when using PythonParser class
    (see #1213)





  - Port redis-py's client implementation to aioredis.
    (see #891)

  - Make hiredis an optional dependency.
    (see #917)






  - Fix transaction data decoding
    (see #657)
  - Fix duplicate calls to `pool.wait_closed()` upon `create_pool()` exception.
    (see #671)



  - Drop explicit loop requirement in API.
    Deprecate `loop` argument.
    Throw warning in Python 3.8+ if explicit `loop` is passed to methods.
    (see #666)



  - (#643, #646, #648)





  - Added `xdel` and `xtrim` method which missed in `commands/streams.py` & also added unit test code for them
    (see #438)
  - Add `count` argument to `spop` command
    (see #485)
  - Add support for `zpopmax` and `zpopmin` redis commands
    (see #550)
  - Add `towncrier`: change notes are now stored in `CHANGES.txt`
    (see #576)
  - Type hints for the library
    (see #584)
  - A few additions to the sorted set commands:
  - the blocking pop commands: `BZPOPMAX` and `BZPOPMIN`
  - the `CH` and `INCR` options of the `ZADD` command
    (see #618)
  - Added `no_ack` parameter to `xread_group` streams method in `commands/streams.py`
    (see #625)



  - Fix for sensitive logging
    (see #459)
  - Fix slow memory leak in `wait_closed` implementation
    (see #498)
  - Fix handling of instances were Redis returns null fields for a stream message (see
    \#605)



  - Rewrite "Getting started" documentation.
    (see #641)



  - #585,
    
    
    
    
    






  - Implemented new Stream command support
    (see #299)
  - Reduce `encode_command()` cost about 60%
    (see #397)



  - Fix pipeline commands buffering was causing multiple `sendto` syscalls
    (see #464)
    and  #473)
  - Python 3.7 compatibility fixes
    (see #426)
  - Fix typos in documentation
    (see #400)
  - Fix `INFO` command result parsing
    (see #405)
  - Fix bug in `ConnectionsPool._drop_closed` method
    (see #461)



  - Update dependencies versions
  - Multiple tests improvements





  - Implement new commands: `wait`, `touch`, `swapdb`, `unlink`
    (see #376)
  - Add `async_op` argument to `flushall` and `flushdb` commands
    (see #364, #370)



  - **Important!** Fix Sentinel sentinel client with pool `minsize`
    greater than 1
    (see #380)
  - Fix `SentinelPool.discover_timeout` usage
    (see #379)
  - Fix `Receiver` hang on disconnect
    (see #354, #366)
  - Fix an issue with `subscribe`/`psubscribe` with empty pool
    (see #351, #355)
  - Fix an issue when `StreamReader`'s feed_data is called before set_parser
    (see #347)



  - Update dependencies versions
  - Multiple test fixes






  - **Important!** Drop Python 3.3, 3.4 support
    (see #321, #323, #326)

  - **Important!** Connections pool has been refactored; now `create_redis`
    function will yield `Redis` instance instead of `RedisPool`
    (see #129)
  - **Important!** Change sorted set commands reply format:
    return list of tuples instead of plain list for commands
    accepting `withscores` argument
    (see #334)
  - **Important!** Change `hscan` command reply format:
    return list of tuples instead of mixed key-value list
    (see #335)
  - Implement Redis URI support as supported `address` argument value
    (see #322)
  - Dropped `create_reconnecting_redis`, `create_redis_pool` should be
    used instead
  - Implement custom `StreamReader`
    (see #273)
  - Implement Sentinel support
    (see #181)
  - Implement pure-python parser
    (see #212)
  - Add `migrate_keys` command
    (see #187)
  - Add `zrevrangebylex` command
    (see #201)
  - Add `command`, `command_count`, `command_getkeys` and
    `command_info` commands
    (see #229)
  - Add `ping` support in pubsub connection
    (see #264)
  - Add `exist` parameter to `zadd` command
    (see #288)
  - Add `MaxClientsError` and implement `ReplyError` specialization
    (see #325)
  - Add `encoding` parameter to sorted set commands
    (see #289)



  - Fix `CancelledError` in `conn._reader_task`
    (see #301)
  - Fix pending commands cancellation with `CancelledError`,
    use explicit exception instead of calling `cancel()` method
    (see #316)
  - Correct error message on Sentinel discovery of master/slave with password
    (see #327)
  - Fix `bytearray` support as command argument
    (see #329)
  - Fix critical bug in patched asyncio.Lock
    (see #256)
  - Fix Multi/Exec transaction canceled error
    (see #225)
  - Add missing arguments to `create_redis` and `create_redis_pool`
  - Fix deprecation warning
    (see #191)
  - Make correct `__aiter__()`
    (see #192)
  - Backward compatibility fix for `with (yield from pool) as conn:`
    (see #205)
  - Fixed pubsub receiver stop()
    (see #211)



  - Multiple test fixes
  - Add PyPy3 to build matrix
  - Update dependencies versions
  - Add missing Python 3.6 classifier






  - Fix for indistinguishable futures cancellation with `asyncio.CancelledError`
    (see #316, cherry-picked from master)






  - Fix time command result decoding when using connection-wide encoding setting
    (see #266)






  - Critical bug fixed in patched asyncio.Lock
    (see #256)






  - Added `zrevrangebylex` command
    (see #201 cherry-picked from master)
  - Add connection timeout
    (see #221, cherry-picked from master)



  - Fixed pool close warning
    (see #239, #236,
    cherry-picked from master
  - Fixed asyncio Lock deadlock issue
    (see #231, #241)






  - Fix pubsub Receiver missing iter() method
    (see #203)






  - Pub/Sub connection commands accept `Channel` instances
    (see #168)
  - Implement new Pub/Sub MPSC (multi-producers, single-consumer) Queue --
    `aioredis.pubsub.Receiver`
    (see #176)
  - Add `aioredis.abc` module providing abstract base classes
    defining interface for basic lib components  (see #176)
  - Implement Geo commands support
    (see #177, #179)



  - Minor tests fixes


  - Update examples and docs to use `async`/`await` syntax
    also keeping `yield from` examples for history
    (see #173)
  - Reflow Travis CI configuration; add Python 3.6 section
    (see #170)
  - Add AppVeyor integration to run tests on Windows
    (see #180)
  - Update multiple development requirements






  - Allow multiple keys in `EXISTS` command
    (see #156, #157)



  - Close RedisPool when connection to Redis failed
    (see #136)
  - Add simple `INFO` command argument validation
    (see #140)
  - Remove invalid uses of `next()`



  - Update devel.rst docs; update Pub/Sub Channel docs (cross-refs)
  - Update MANIFEST.in to include docs, examples and tests in source bundle






  - Add `hmset_dict` command
    (see #130)
  - Add `RedisConnection.address` property
  - RedisPool `minsize`/`maxsize` must not be `None`
  - Implement `close()`/`wait_closed()`/`closed` interface for pool
    (see #128)



  - Add test for `hstrlen`
  - Test fixes



  - Enable Redis 3.2.0 on Travis
  - Add spell checking when building docs
    (see #132)
  - Documentation updated




  - `create_pool()` minsize default value changed to 1
  - Fixed cancellation of wait_closed
    (see #118)
  - Fixed `time()` conversion to float
    (see #126)
  - Fixed `hmset()` method to return bool instead of `b'OK'`
    (see [#12))
  - Fixed multi/exec + watch issue (changed watch variable was causing
    `tr.execute()` to fail)
    (see #121)
  - Replace `asyncio.Future` uses with utility method
    (get ready to Python 3.5.2 `loop.create_future()`)
  - Tests switched from unittest to pytest (see [#12))
  - Documentation updates




  - Fixed Multi/Exec transactions cancellation issue
    (see #110, #114)
  - Fixed Pub/Sub subscribe concurrency issue
    (see #113, #115)
  - Add SSL/TLS support
    (see  #116)
  - `aioredis.ConnectionClosedError` raised in `execute_pubsub` as well
    (see #108)
  - `Redis.slaveof()` method signature changed: now to disable
    replication one should call `redis.slaveof(None)` instead of `redis.slaveof()`
  - More tests added




  - Close all Pub/Sub channels on connection close
    (see #88)
  - Add `iter()` method to `aioredis.Channel` allowing to use it
    with `async for`
    (see #89)
  - Inline code samples in docs made runnable and downloadable
    (see #92)
  - Python 3.5 examples converted to use `async`/`await` syntax
    (see #93)
  - Fix Multi/Exec to honor encoding parameter
    (see #94, #97)
  - Add debug message in `create_connection`
    (see #90)
  - Replace `asyncio.async` calls with wrapper that respects asyncio version
    (see #101)
  - Use NODELAY option for TCP sockets
    (see #105)
  - New `aioredis.ConnectionClosedError` exception added. Raised if
    connection to Redis server is lost
    (see #108, #109)
  - Fix RedisPool to close and drop connection in subscribe mode on release
  - Fix `aioredis.util.decode` to recursively decode list responses
  - More examples added and docs updated
  - Add google groups link to README
  - Bump year in LICENSE and docs




  - Python 3.5 `async` support:

    - New scan commands API (`iscan`, `izscan`, `ihscan`)
    - Pool made awaitable (allowing `with await pool: ...` and `async
      with pool.get() as conn:` constructs)
  - Fixed dropping closed connections from free pool
    (see #83)
  - Docs updated




  - Redis cluster support work in progress
  - Fixed pool issue causing pool growth over max size & `acquire` call hangs
    (see #71)
  - `info` server command result parsing implemented
  - Fixed behavior of util functions
    (see #70)
  - `hstrlen` command added
  - Few fixes in examples
  - Few fixes in documentation




  - Decoding data with `encoding` parameter now takes into account
    list (array) replies
    (see #68)
  - `encoding` parameter added to following commands:

    - generic commands: keys, randomkey
    - hash commands: hgetall, hkeys, hmget, hvals
    - list commands: blpop, brpop, brpoplpush, lindex, lpop, lrange, rpop, rpoplpush
    - set commands: smembers, spop, srandmember
    - string commands: getrange, getset, mget
  - Backward incompatibility:

    `ltrim` command now returns bool value instead of 'OK'
  - Tests updated




  - Logging added (aioredis.log module)
  - Fixed issue with `wait_message` in pub/sub
    (see #66)




  - Pub/Sub support added
  - Fix in `zrevrangebyscore` command
    (see #62)
  - Fixes/tests/docs




  - AutoConnector added
  - wait_closed method added for clean connections shutdown
  - `zscore` command fixed
  - Test fixes




  - Dropped following Redis methods -- `Redis.multi()`,
    `Redis.exec()`, `Redis.discard()`
  - `Redis.multi_exec` hack'ish property removed
  - `Redis.multi_exec()` method added
  - High-level commands implemented:

    - generic commands (tests)
    - transactions commands (api stabilization).

  - Backward incompatibilities:

    - Following sorted set commands' API changed:

      `zcount`, `zrangebyscore`, `zremrangebyscore`, `zrevrangebyscore`
    - set string command' API changed





  - RedisConnection.execute refactored to support commands pipelining
    (see #33)
  - Several fixes
  - WIP on transactions and commands interface
  - High-level commands implemented and tested:

    - hash commands
    - hyperloglog commands
    - set commands
    - scripting commands
    - string commands
    - list commands




  - `create_connection`, `create_pool`, `create_redis` functions updated: db and password
    arguments made keyword-only
    (see #26)
  - Fixed transaction handling
    (see #32)
  - Response decoding
    (see #16)




  - Transactions support (in connection, high-level commands have some issues)
  - Docs & tests updated.





  - Initial release
  - RedisConnection implemented
  - RedisPool implemented
  - Docs for RedisConnection & RedisPool
  - WIP on high-level API.


pkgId: 38e488bd8352b101017651d0c115c1fc885c7f945079c161930b2a1c79f29574
name: python-aioredis-cluster
arch: src
version: 2.7.0
epoch: 0
release: 1
summary: Redis Cluster support extension for aioredis
url: https://pypi.org/project/aioredis-cluster/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioredis-cluster-2.7.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/aioredis-cluster)](https://pypi.org/project/aioredis-cluster/) ![aioredis-cluster CI/CD](https://github.com/DriverX/aioredis-cluster/workflows/aioredis-cluster%20CI/CD/badge.svg)
  Redis Cluster support for [aioredis](https://github.com/aio-libs/aioredis) (support only v1.x.x).
  Many implementation features were inspired by [go-redis](https://github.com/go-redis/redis) project.


pkgId: 1d50b5691397c81716e04f33ba6dc6f6d05ef607ceb437501fce00f0d3f77c73
name: python-aioredis-lock
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Wrapper to provide distributed locks in aioredis
url: https://github.com/mrasband/aioredis-lock
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioredis-lock-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/mrasband/aioredis-lock.svg?style=svg)](https://circleci.com/gh/mrasband/aioredis-lock)

  Implementation of distributed locking with [aioredis](https://github.com/aio-libs/aioredis), an asyncio based redis client.

  This is a standalone lib until, and if, [aio-libs/aioredis#573](https://github.com/aio-libs/aioredis/pull/573) is accepted.



  You need an `aioredis.RedisConnection` or `aioredis.ConnectionsPool` already created.



  ```python
  from aioredis_lock import RedisLock, LockTimeoutError

  try:
      async with RedisLock(
          pool,
          key="foobar",
          
          
          timeout=30,
          
          
          wait_timeout=30,
      ) as lock:
          
          

          

          
          await lock.extend(30)

  except LockTimeoutError:
      
      pass
  ```



  Let's suppose you need a simple leader/follower type implementation where you have a number of web-workers but just want 1 to preform a repeated task. In the case the leader fails someone else should pick up the work. Simply pass `wait_timeout=None` to RedisLock allowing the worker to keep trying to get a lock for when the leader eventually fails. The main complication here is extending the lock and validating the leader still owns it.

  ```python
  from aioredis_lock import RedisLock


  while True:

      
      async with RedisLock(pool, "shared_key", wait_timeout=None) as lock:

          
          while True:
              if not await lock.is_owner():
                  logger.debug("We are no longer the lock owner, falling back")
                  break

              

              if not await lock.renew():
                  logger.debug("We lost the lock, falling back to follower mode")
                  break
  ```

  This mostly delegates the work of selecting and more importantly promoting leaders.


pkgId: 34332b47935737a0e4b5be74c5663d99860c37da2d99e2d78f99dcd69945650c
name: python-aioredis-models
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Model Redis data structures
url: https://github.com/qcrisw/aioredis-models
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioredis-models-3.0.0-1.src.rpm
checksum_type: sha256
description:
  A wrapper over [aioredis](https://github.com/aio-libs/aioredis) that models
  [Redis](https://redis.io/) data as simple data structures.

  ![GitHub](https://img.shields.io/github/license/qcrisw/aioredis-models)
  ![PyPI](https://img.shields.io/pypi/v/aioredis_models)

  ![GitHub Workflow Status (event)](https://img.shields.io/github/workflow/status/qcrisw/aioredis-models/quality-check?event=push&label=quality-checks)
  [![Documentation Status](https://readthedocs.org/projects/aioredis-models/badge/?version=latest)](https://aioredis-models.readthedocs.io/en/latest/?badge=latest)
  [![codecov](https://codecov.io/gh/qcrisw/aioredis-models/branch/main/graph/badge.svg?token=5K5M77QXO5&flag=unit-tests)](https://codecov.io/gh/qcrisw/aioredis-models)
  ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/qcrisw/aioredis-models/publish-package?label=package-publish)



  - [x] Keys
  - [x] Strings
  - [x] Lists
  - [x] Hash maps
  - [x] Sets
  - [x] Double hash maps



  - Python 3.6+
  - [aioredis](https://github.com/aio-libs/aioredis) requirements



  Detailed documentation is available at https://aioredis-models.readthedocs.io/.



  Construction of all data structures requires at least an `aioredis.Redis` instance
  and a key. For example, to create a `RedisString`:

  ``` python
  from aioredis-models import RedisString

  redis_string = RedisString(redis, 'my-string')
  ```

  Once a model has been constructed, various functions can be used to interact with it.

  ``` python
  import aioredis
  from aioredis-models import RedisString

  async def do_work(redis_string: RedisString):
    stored_value = await redis_string.get()
    print(stored_value)
  ```



  The library is currently in very early stages of development and there is a lot of room for growth.
  As such, contributions are welcome. To contribute, create a pull request into the `main` branch.
  Make sure the tests pass and there are no linting errors. Also, please update documentation, if
  needed.



  The easiest way to run the tests is through [docker-compose] and [Docker]:

  ``` bash
  docker-compose up --build unit-test
  ```

  To run directly on the host:

  ``` bash
  pip3 install -r requirements.txt
  tox -e unit-py39
  ```

  End-to-end tests can also be run with [docker-compose]:

  ``` bash
  docker-compose up --build e2e-test
  ```



  Similar to testing, linting rules can be run through:

  ``` bash
  docker-compose up --build lint
  ```

  To run directly on the host:

  ``` bash
  pip3 install -r requirements.txt
  pylint aioredis_models
  ```



  Documentation can get regenerated by starting the `generate-docs` service in docker-compose:

  ``` bash
  docker-compose up --build generate-docs
  ```

  To run directly on the host:

  ``` bash
  pip3 install -r requirements.txt
  sphinx-apidoc -f -o docs/source aioredis_models && (cd docs && make html)
  ```



  This library is offered under the MIT license.


  [docker-compose]: https://docs.docker.com/compose/install/ "docker-compose"
  [docker]: https://docs.docker.com/get-docker/ "Docker"


pkgId: 6e2e9b3ae9eace1adfbbf8dc67aa8c5f942a56eb7b9f2f9831844ed857683d67
name: python-aioregistry
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Python library for interacting with container image registries
url: http://github.com/msg555/aioregistry
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioregistry-0.7.2-1.src.rpm
checksum_type: sha256
description:
  `aioregistry` is a Python library and CLI tool for inspecting and copying container image data
  from and between registries.

  This library primarily focuses on being a useful tool for dealing with container image
  registries. It has very limited support for interpretation of the objects stored within.




  ```python
  async with AsyncRegistryClient() as client:
      manifest_ref = parse_image_name("alpine")
      manifest = await client.manifest_download(manifest_ref)

      if isinstance(manifest, ManifestListV2S2):
          for sub_manifest in manifest.manifests:
              if sub_manifest.platform.architecture == "amd64":
                  manifest_ref.ref = sub_manifest.digest
                  manifest = await client.manifest_download(manifest_ref)
                  break
          else:
              raise Exception("Found no matching platform")
      else:
          print("Not a manifest list")
  ```



  ```python
  for layer in manifest.layers:
      assert layer.media_type == "application/vnd.docker.image.rootfs.diff.tar.gzip"
      blob_ref = RegistryBlobRef(manifest_ref.registry, manifest_ref.repo, layer.digest)

      
      blob_data = io.BytesIO(
          b"".join([chunk async for chunk in client.ref_content_stream(blob_ref)])
      )
      with tarfile.open(mode="r|*", fileobj=blob_data) as tar:
          for tarinfo in tar.getmembers():
              print(tarinfo.name)
  ```



  ```sh

  python -m aioregistry ubuntu:18.04 my.private.registry/my-repo:my-tag
  ```

  ```sh

  python -m aioregistry ubuntu my.private.registry/my-repo --tag-pattern '18\..*'


pkgId: 8b6492f72e83f8c72f5500342ec72a08435493aa084451173faf1f459ab0ac63
name: python-aioreloader
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Port of tornado reloader to asyncio
url: https://github.com/and800/aioreloader
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioreloader-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Tool that reloads your `asyncio <https://docs.python.org/3/library/asyncio.html>`_-based application automatically when you
  modify the source code.
  Most of code has been borrowed from
  `Tornado <https://github.com/tornadoweb/tornado/blob/master/tornado/autoreload.py>`_
  reloader built mostly by `@finiteloop <https://github.com/finiteloop>`_
  and `@bdarnell <https://github.com/bdarnell>`_. Thanks!
  From 0.3.x version aioreloader natively supports `-X` python arguments. Which is recommended way for development debug mode in aiohttp.


pkgId: 0a2373fcbc23a01f9d737072c8f645c2b94a9f28fcf8a7294e18bd574e41ab8c
name: python-aioretry
arch: src
version: 6.0.1
epoch: 0
release: 1
summary: Asyncio retry utility for Python 3.7+
url: https://github.com/kaelzhang/python-aioretry
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioretry-6.0.1-1.src.rpm
checksum_type: sha256
description:
  [![](https://github.com/kaelzhang/python-aioretry/actions/workflows/python.yml/badge.svg)](https://github.com/kaelzhang/python-aioretry/actions/workflows/python.yml)
  [![](https://codecov.io/gh/kaelzhang/python-aioretry/branch/master/graph/badge.svg)](https://codecov.io/gh/kaelzhang/python-aioretry)
  [![](https://img.shields.io/pypi/v/aioretry.svg)](https://pypi.org/project/aioretry/)
  [![](https://img.shields.io/pypi/l/aioretry.svg)](https://github.com/kaelzhang/python-aioretry)



  Asyncio retry utility for Python 3.7+

  - [Upgrade guide](#upgrade-guide)



  ```sh
  $ pip install aioretry
  ```

  A [conda-forge recipe](https://github.com/conda-forge/aioretry-feedstock) is also available, so you can also use

  ```py
  conda install -c conda-forge aioretry
  ```



  ```py
  import asyncio

  from aioretry import (
      retry,
      
      RetryPolicyStrategy,
      RetryInfo
  )


  def retry_policy(info: RetryInfo) -> RetryPolicyStrategy:
      """
      - It will always retry until succeeded: abandon = False
      - If fails for the first time, it will retry immediately,
      - If it fails again,
        aioretry will perform a 100ms delay before the second retry,
        200ms delay before the 3rd retry,
        the 4th retry immediately,
        100ms delay before the 5th retry,
        etc...
      """
      return False, (info.fails - 1) % 3 * 0.1


  @retry(retry_policy)
  async def connect_to_server():
      
      ...

  asyncio.run(connect_to_server())
  ```



  We could also use `retry` as a decorator for instance method

  ```py
  class Client:
      @retry(retry_policy)
      async def connect(self):
          await self._connect()

  asyncio.run(Client().connect())
  ```



  `retry_policy` could be the method name of the class if `retry` is used as a decorator for instance method.

  ```py
  class ClientWithConfigurableRetryPolicy(Client):
      def __init__(self, max_retries: int = 3):
          self._max_retries = max_retries

      def _retry_policy(self, info: RetryInfo) -> RetryPolicyStrategy:
          return info.fails > self._max_retries, info.fails * 0.1

      
      
      
      @retry('_retry_policy')
      async def connect(self):
          await self._connect()

  asyncio.run(ClientWithConfigurableRetryPolicy(10).connect())
  ```



  We could also register an `before_retry` callback which will be executed after every failure of the target function if the corresponding retry is not abandoned.

  ```py
  class ClientTrackableFailures(ClientWithConfigurableRetryPolicy):
      
      async def _before_retry(self, info: RetryInfo) -> None:
          await self._send_failure_log(info.exception, info.fails)

      @retry(
        retry_policy='_retry_policy',

        
        
        before_retry='_before_retry'
      )
      async def connect(self):
          await self._connect()
  ```



  ```py
  def retry_policy(info: RetryInfo) -> RetryPolicyStrategy:
      if isinstance(info.exception, (KeyError, ValueError)):
          
          return True, 0

      
      return False, 0

  @retry(retry_policy)
  async def foo():
      
      ...
  ```





  - **fn** `Callable[[...], Awaitable]` the function to be wrapped. The function should be an async function or normal function returns an awaitable.
  - **retry_policy** `Union[str, RetryPolicy]`
  - **before_retry?** `Optional[Union[str, Callable[[RetryInfo], Optional[Awaitable]]]]` If specified, `before_retry` is called after each failure of `fn` and before the corresponding retry. If the retry is abandoned, `before_retry` will not be executed.

  Returns a wrapped function which accepts the same arguments as `fn` and returns an `Awaitable`.



  ```py
  RetryPolicy = Callable[[RetryInfo], Tuple[bool, Union[float, int]]]
  ```

  Retry policy is used to determine what to do next after the `fn` fails to do some certain thing.

  ```py
  abandon, delay = retry_policy(info)
  ```

  - **info** `RetryInfo`
    - **info.fails** `int` is the counter number of how many times function `fn` performs as a failure. If `fn` fails for the first time, then `fails` will be `1`.
    - **info.exception** `Exception` is the exception that `fn` raised.
    - **info.since** `float` is the fractional time seconds generated by [`time.monotonic()`](https://docs.python.org/3/library/time.html#time.monotonic) when the first failure happens.
  - If `abandon` is `True`, then aioretry will give up the retry and raise the exception directly, otherwise aioretry will sleep `delay` seconds (`asyncio.sleep(delay)`) before the next retry.

  ```py
  def retry_policy(info: RetryInfo):
      if isinstance(info.exception, KeyError):
          
          return True, 0

      return False, info.fails * 0.1
  ```



  ```py
  from aioretry import (
      
      RetryPolicy,
      
      RetryPolicyStrategy,
      
      BeforeRetry,
      RetryInfo
  )
  ```



  Since `5.0.0`, aioretry introduces `RetryInfo` as the only parameter of `retry_policy` or `before_retry`



  2.x

  ```py
  def retry_policy(fails: int):
      """A policy that gives no chances to retry
      """

      return True, 0.1 * fails
  ```

  5.x

  ```py
  def retry_policy(info: RetryInfo):
      return True, 0.1 * info.fails
  ```



  3.x

  ```py
  def before_retry(e: Exception, fails: int):
      ...
  ```

  5.x

  ```py

  def before_retry(info: RetryInfo):
      info.exception
      info.fails
      ...
  ```



  Since `5.0.0`, both `retry_policy` and `before_retry` have only one parameter of type `RetryInfo` respectively.



  Since `6.0.0`, `RetryInfo::since` is a `float` value which is generated by [`time.monotonic()`](https://docs.python.org/3/library/time.html#time.monotonic) and is better for measuring intervals than `datetime`, while in `5.x` `RetryInfo::since` is a `datetime`

  ```py

  from datetime import datetime

  def retry_policy(info: RetryInfo) -> RetryPolicyStrategy:
      print('error occurred', (datetime.now() - info.since).total_seconds(), 'seconds ago')

      ...
  ```

  ```py

  import time

  def retry_policy(info: RetryInfo) -> RetryPolicyStrategy:
      print('error occurred', time.monotonic() - info.since, 'seconds ago')

      ...
  ```



  [MIT](LICENSE)

rpm_license:
  Copyright (c) 2013 kaelzhang <>, contributors  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.


pkgId: 7280a606ab8abde487811fed8f7bd83b005f414e96dad74aa5e2ceafb73d36a8
name: python-aioretry
arch: src
version: 6.2.0
epoch: 0
release: 1
summary: Asyncio retry utility for Python 3.7+
url: https://github.com/kaelzhang/python-aioretry
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioretry-6.2.0-1.src.rpm
checksum_type: sha256
description:
  [![](https://github.com/kaelzhang/python-aioretry/actions/workflows/python.yml/badge.svg)](https://github.com/kaelzhang/python-aioretry/actions/workflows/python.yml)
  [![](https://codecov.io/gh/kaelzhang/python-aioretry/branch/master/graph/badge.svg)](https://codecov.io/gh/kaelzhang/python-aioretry)
  [![](https://img.shields.io/pypi/v/aioretry.svg)](https://pypi.org/project/aioretry/)
  [![](https://img.shields.io/pypi/l/aioretry.svg)](https://github.com/kaelzhang/python-aioretry)



  Asyncio retry utility for Python 3.7+

  - [Upgrade guide](#upgrade-guide)



  ```sh
  $ pip install aioretry
  ```

  A [conda-forge recipe](https://github.com/conda-forge/aioretry-feedstock) is also available, so you can also use

  ```sh
  conda install -c conda-forge aioretry
  ```



  ```py
  import asyncio

  from aioretry import (
      retry,
      
      RetryPolicyStrategy,
      RetryInfo
  )


  def retry_policy(info: RetryInfo) -> RetryPolicyStrategy:
      """
      - It will always retry until succeeded: abandon = False
      - If fails for the first time, it will retry immediately,
      - If it fails again,
        aioretry will perform a 100ms delay before the second retry,
        200ms delay before the 3rd retry,
        the 4th retry immediately,
        100ms delay before the 5th retry,
        etc...
      """
      return False, (info.fails - 1) % 3 * 0.1


  @retry(retry_policy)
  async def connect_to_server():
      
      ...

  asyncio.run(connect_to_server())
  ```



  We could also use `retry` as a decorator for instance method

  ```py
  class Client:
      @retry(retry_policy)
      async def connect(self):
          await self._connect()

  asyncio.run(Client().connect())
  ```



  `retry_policy` could be the method name of the class if `retry` is used as a decorator for instance method.

  ```py
  class ClientWithConfigurableRetryPolicy(Client):
      def __init__(self, max_retries: int = 3):
          self._max_retries = max_retries

      def _retry_policy(self, info: RetryInfo) -> RetryPolicyStrategy:
          return info.fails > self._max_retries, info.fails * 0.1

      
      
      
      @retry('_retry_policy')
      async def connect(self):
          await self._connect()

  asyncio.run(ClientWithConfigurableRetryPolicy(10).connect())
  ```



  We could also register an `before_retry` callback which will be executed after every failure of the target function if the corresponding retry is not abandoned.

  ```py
  class ClientTrackableFailures(ClientWithConfigurableRetryPolicy):
      
      async def _before_retry(self, info: RetryInfo) -> None:
          await self._send_failure_log(info.exception, info.fails)

      @retry(
        retry_policy='_retry_policy',

        
        
        before_retry='_before_retry'
      )
      async def connect(self):
          await self._connect()
  ```



  ```py
  def retry_policy(info: RetryInfo) -> RetryPolicyStrategy:
      if isinstance(info.exception, (KeyError, ValueError)):
          
          return True, 0

      
      return False, 0

  @retry(retry_policy)
  async def foo():
      
      ...
  ```





  - **fn** `Callable[[...], Awaitable]` the function to be wrapped. The function should be an async function or normal function returns an awaitable.
  - **retry_policy** `Union[str, RetryPolicy]`
  - **before_retry?** `Optional[Union[str, Callable[[RetryInfo], Optional[Awaitable]]]]` If specified, `before_retry` is called after each failure of `fn` and before the corresponding retry. If the retry is abandoned, `before_retry` will not be executed.

  Returns a wrapped function which accepts the same arguments as `fn` and returns an `Awaitable`.



  ```py
  RetryPolicyStrategy = Tuple[bool, int | float]
  RetryPolicy = Callable[[RetryInfo], RetryPolicyStrategy | Awaitable[RetryPolicyStrategy]]
  ```

  Retry policy is used to determine what to do next after the `fn` fails to do some certain thing.

  ```py
  rt = retry_policy(info)

  abandon, delay = (
      
      await rt
      if inspect.isawaitable(rt)
      else rt
  )
  ```

  - **info** `RetryInfo`
    - **info.fails** `int` is the counter number of how many times function `fn` performs as a failure. If `fn` fails for the first time, then `fails` will be `1`.
    - **info.exception** `Exception` is the exception that `fn` raised.
    - **info.since** `float` is the fractional time seconds generated by [`time.monotonic()`](https://docs.python.org/3/library/time.html#time.monotonic) when the first failure happens.
  - If `abandon` is `True`, then aioretry will give up the retry and raise the exception directly, otherwise aioretry will sleep `delay` seconds (`asyncio.sleep(delay)`) before the next retry.

  ```py
  def retry_policy(info: RetryInfo):
      if isinstance(info.exception, KeyError):
          
          return True, 0

      return False, info.fails * 0.1
  ```



  ```py
  from aioretry import (
      
      RetryPolicy,
      
      RetryPolicyStrategy,
      
      BeforeRetry,
      RetryInfo
  )
  ```



  Since `5.0.0`, aioretry introduces `RetryInfo` as the only parameter of `retry_policy` or `before_retry`



  2.x

  ```py
  def retry_policy(fails: int):
      """A policy that gives no chances to retry
      """

      return True, 0.1 * fails
  ```

  5.x

  ```py
  def retry_policy(info: RetryInfo):
      return True, 0.1 * info.fails
  ```



  3.x

  ```py
  def before_retry(e: Exception, fails: int):
      ...
  ```

  5.x

  ```py

  def before_retry(info: RetryInfo):
      info.exception
      info.fails
      ...
  ```



  Since `5.0.0`, both `retry_policy` and `before_retry` have only one parameter of type `RetryInfo` respectively.



  Since `6.0.0`, `RetryInfo::since` is a `float` value which is generated by [`time.monotonic()`](https://docs.python.org/3/library/time.html#time.monotonic) and is better for measuring intervals than `datetime`, while in `5.x` `RetryInfo::since` is a `datetime`

  ```py

  from datetime import datetime

  def retry_policy(info: RetryInfo) -> RetryPolicyStrategy:
      print('error occurred', (datetime.now() - info.since).total_seconds(), 'seconds ago')

      ...
  ```

  ```py

  import time

  def retry_policy(info: RetryInfo) -> RetryPolicyStrategy:
      print('error occurred', time.monotonic() - info.since, 'seconds ago')

      ...
  ```



  [MIT](LICENSE)

rpm_license:
  Copyright (c) 2013 kaelzhang <>, contributors  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.


pkgId: c30064055647c6308654565a9b3542ebda48c4eecb22e1ef4f9d81d3e5197c97
name: python-aioridwell
arch: src
version: 2024.1.0
epoch: 0
release: 1
summary: A Python3, asyncio-based API for interacting with Ridwell waste recycling
url: https://github.com/bachya/aioridwell
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioridwell-2024.1.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>

  `aioridwell` is a Python 3, asyncio-friendly library for interacting with
  [Ridwell][ridwell] to view information on upcoming recycling pickups.

  - [Installation](#installation)
  - [Python Versions](#python-versions)
  - [Usage](#usage)
  - [Contributing](#contributing)



  ```bash
  pip install aioridwell
  ```



  `aioridwell` is currently supported on:

  - Python 3.10
  - Python 3.11
  - Python 3.12





  The `Client` is the primary method of interacting with the API:

  ```python
  import asyncio

  from aioridwell import async_get_client


  async def main() -> None:
      client = await async_get_client("<EMAIL>", "<PASSWORD>")
      


  asyncio.run(main())
  ```

  By default, the library creates a new connection to the API 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`][aiohttp] `ClientSession` can be used for
  connection pooling:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from aiowatttime import Client


  async def main() -> None:
      async with ClientSession() as session:
          client = await async_get_client("<EMAIL>", "<PASSWORD>", session=session)
          


  asyncio.run(main())
  ```



  ```python
  import asyncio

  from aioridwell import async_get_client


  async def main() -> None:
      client = await async_get_client("<EMAIL>", "<PASSWORD>")
      client.get_dashboard_url()
      


  asyncio.run(main())
  ```



  Getting all accounts associated with this email address is easy:

  ```python
  import asyncio

  from aioridwell import async_get_client


  async def main() -> None:
      client = await async_get_client("<EMAIL>", "<PASSWORD>")

      accounts = await client.async_get_accounts()
      


  asyncio.run(main())
  ```

  The `RidwellAccount` object comes with some useful properties:

  - `account_id`: the Ridwell ID for the account
  - `address`: the address being serviced
  - `email`: the email address on the account
  - `full_name`: the full name of the account owner
  - `phone`: the phone number of the account owner
  - `subscription_id`: the Ridwell ID for the primary subscription
  - `subscription_active`: whether the primary subscription is active



  Getting pickup events associated with an account is easy, too:

  ```python
  import asyncio

  from aioridwell import async_get_client


  async def main() -> None:
      client = await async_get_client("<EMAIL>", "<PASSWORD>")

      accounts = await client.async_get_accounts()
      for account in accounts.values():
          events = await account.async_get_pickup_events()
          

          
          next_event = await account.async_get_next_pickup_event()
          


  asyncio.run(main())
  ```

  The `RidwellPickupEvent` object comes with some useful properties:

  - `pickup_date`: the date of the pickup (in `datetime.date` format)
  - `pickups`: a list of `RidwellPickup` objects
  - `state`: an `EventState` enum whose name represents the current state of the pickup event

  Likewise, the `RidwellPickup` object comes with some useful properties:

  - `category`: a `PickupCategory` enum whose name represents the type of pickup
  - `name`: the name of the item being picked up
  - `offer_id`: the Ridwell ID for this particular offer
  - `priority`: the pickup priority
  - `product_id`: the Ridwell ID for this particular product
  - `quantity`: the amount of the product being picked up



  ```python
  import asyncio

  from aioridwell import async_get_client


  async def main() -> None:
      client = await async_get_client("<EMAIL>", "<PASSWORD>")

      accounts = await client.async_get_accounts()
      for account in accounts.values():
          events = await account.async_get_pickup_events()
          

          await events[0].async_opt_in()
          await events[0].async_opt_out()


  asyncio.run(main())
  ```



  ```python
  import asyncio

  from aioridwell import async_get_client


  async def main() -> None:
      client = await async_get_client("<EMAIL>", "<PASSWORD>")

      accounts = await client.async_get_accounts()
      for account in accounts.values():
          events = await account.async_get_pickup_events()
          

          event_1_cost = await events[0].async_get_estimated_addon_cost()
          


  asyncio.run(main())
  ```



  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 aioridwell tests`
  9. Update `README.md` with any new documentation.
  10. Submit a pull request!

  [aiohttp]: https://github.com/aio-libs/aiohttp
  [ci-badge]: https://img.shields.io/github/actions/workflow/status/bachya/aioridwell/test.yml
  [ci]: https://github.com/bachya/aioridwell/actions
  [codecov-badge]: https://codecov.io/gh/bachya/aioridwell/branch/dev/graph/badge.svg
  [codecov]: https://codecov.io/gh/bachya/aioridwell
  [contributors]: https://github.com/bachya/aioridwell/graphs/contributors
  [fork]: https://github.com/bachya/aioridwell/fork
  [issues]: https://github.com/bachya/aioridwell/issues
  [license-badge]: https://img.shields.io/pypi/l/aioridwell.svg
  [license]: https://github.com/bachya/aioridwell/blob/main/LICENSE
  [maintainability-badge]: https://api.codeclimate.com/v1/badges/9c1dcc1c991cecb06eda/maintainability
  [maintainability]: https://codeclimate.com/github/bachya/aioridwell/maintainability
  [new-issue]: https://github.com/bachya/aioridwell/issues/new
  [new-issue]: https://github.com/bachya/aioridwell/issues/new
  [pypi-badge]: https://img.shields.io/pypi/v/aioridwell.svg
  [pypi]: https://pypi.python.org/pypi/aioridwell
  [ridwell]: https://ridwell.com
  [version-badge]: https://img.shields.io/pypi/pyversions/aioridwell.svg
  [version]: https://pypi.python.org/pypi/aioridwell


pkgId: 91eaa2aa320ceb3cca8ae52b96b5f3764be130b54890d269d03b3d21b9b3b4d2
name: python-aiorinnai
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Python interface for Rinnai Control-R API
url: https://github.com/explosivo22/aio-rinnaicontrolr
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiorinnai-0.3.4-1.src.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/aiorinnai?style=for-the-badge)](https://pypi.org/project/aiorinnai)
  [![License](https://img.shields.io/github/license/explosivo22/aio-rinnaicontrolr?style=for-the-badge)](https://opensource.org/licenses/Apache-2.0)

  Python library for communicating with the [Rinnai Control-R Water Heaters and control devices](https://www.rinnai.us/tankless-water-heater/accessories/wifi) via the Rinnai Control-R cloud API.

  ***WARNING***
  * This library only works if you have migrated to the Rinnai 2.0 app.  This will require a firmware update to your Control-R module.
  * [IOS](https://apps.apple.com/us/app/rinnai-control-r-2-0/id1180734911?app=itunes&ign-mpt=uo%3D4)
  * [Android](https://play.google.com/store/apps/details?id=com.controlr)

  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.



  - starting/stop recirculation
  - setting temperature



  ```
  pip install aiorinnai==0.3.0
  ```



  ```python
  import asyncio

  from aiohttp import ClientSession

  from aiorinnai import async_get_api


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

      
      user_info = await api.user.get_info()

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

      
      
      start_recirculation = await api.device.start_recirculation(device_info['data']['getDevices'], 5)

      
      stop_recirculation = await api.device.stop_recirculation(device_info['data']['getDevices'])

      
      
      set_temperature = await api.device.set_temperature(device_info['data']['getDevices'], 130)


  asyncio.run(main())

  ```
  By default, the library creates a new connection to Rinnai 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 ClientSession can be used for connection pooling:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from aiorinnai 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=websession)

      
      user_info = await api.user.get_info()

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

      
      
      start_recirculation = await api.device.start_recirculation(user_info["id"], first_device_id, 5)

      print(start_recirculation)

      
      stop_recirculation = await api.device.stop_recirculation(user_info["id"], first_device_id)

      print(stop_recirculation)

      
      
      set_temperature = await api.device.set_temperature(user_info["id"], first_device_id, 130)


  asyncio.run(main())
  ```



  * not all APIs supported


pkgId: dd8ee1a14d47d76536cf8d7a69bcd9bd66f89d778bec18963fd0a40a44f67248
name: python-aiorpcX
arch: src
version: 0.23.1
epoch: 0
release: 1
summary: Generic async RPC implementation, including JSON-RPC
description: Transport, protocol and framing-independent async RPC client and server implementation.
url: https://pypi.org/project/aiorpcX/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiorpcX-0.23.1-1.src.rpm
checksum_type: sha256
rpm_license:
  Copyright (c) 2018 Neil Booth  All rights reserved.  The MIT License (MIT)  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.


pkgId: 22f7609ec49ddab63bd6bfe294011155aa3056640b128fd6a9aad816c270d7a2
name: python-aiortsp
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: An asyncio-based RTSP library
url: https://github.com/marss/aiortsp
rpm_license: GNU Lesser General Public License v3 or later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiortsp-1.4.0-1.src.rpm
checksum_type: sha256
description:
  This is a very simple asyncio library for interacting with an
  RTSP server, with basic RTP/RTCP support.
  The intended use case is to provide a pretty low level control
  of what happens at RTSP connection level, all in python/asyncio.
  This library does not provide any decoding capability,
  it is up to the client to decide what to do with received RTP packets.
  One could easily decode using `OpenCV <https://pypi.org/project/opencv-python/>`_
  or `PyAV <https://pypi.org/project/av/>`_, or not at all depending on the intended
  use.
  See ``examples`` for how to use the lib internals, butfor quick usage:
      import asyncio
      from aiortsp.rtsp.reader import RTSPReader
      async def main():
          
          async with RTSPReader('rtsp://cam/video.sdp') as reader:
              
              async for pkt in reader.iter_packets():
                  print('PKT', pkt.seq, pkt.pt, len(pkt))
      asyncio.run(main())


pkgId: a8df1c9490a5677ff19130f55697807f473ea8eb5c8a913502634dd27f6fb15a
name: python-aioruckus
arch: src
version: 0.41
epoch: 0
release: 1
summary: Python API to interact with Ruckus Unleashed and ZoneDirector devices.
url: https://github.com/ms264556/aioruckus
rpm_license: BSD0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioruckus-0.41-1.src.rpm
checksum_type: sha256
description:
  A Python API which interacts with Ruckus Unleashed and ZoneDirector devices via their AJAX Web Service interface.
  Configuration information can also be queried from Ruckus Unleashed and ZoneDirector backup files.

  Compatible with all Ruckus Unleashed versions, and Ruckus ZoneDirector versions 9.10 onwards.



  ```bash
  pip install aioruckus
  ```



  Functions are defined within an [async](https://docs.python.org/3/library/asyncio.html) [context manager](https://docs.python.org/3/reference/datamodel.html#context-managers), so you will have to use [asyncio](https://docs.python.org/3/library/asyncio.html) rather than calling the functions directly in a shell.

  ```python
  from aioruckus import AjaxSession, BackupSession, SystemStat
  import asyncio

  async def test_aioruckus():

      async with AjaxSession.async_create("<ruckus ip>", "<ruckus user>", "<ruckus password>") as session:
          ruckus = session.api

          
          
          
          
          aps = await ruckus.get_aps()
          ap_groups = await ruckus.get_ap_groups()
          wlans = await ruckus.get_wlans()
          wlan_groups = await ruckus.get_wlan_groups() # WLAN Groups are CLI-only on Unleashed
          dpsks = await ruckus.get_dpsks()
          mesh = await ruckus.get_mesh_info()
          default_system_info = await ruckus.get_system_info()
          all_system_info = await ruckus.get_system_info(SystemStat.ALL)

          
          
          
          active_clients = await ruckus.get_active_clients()
          inactive_clients = await ruckus.get_inactive_clients() # always empty on Unleashed
          blocked_clients = await ruckus.get_blocked_client_macs()
          
          await ruckus.do_block_client("60:ab:de:ad:be:ef")
          await ruckus.do_unblock_client("60:ab:de:ad:be:ef")
          
          new_rogues = await ruckus.get_active_rogues()
          known_rogues = await ruckus.get_known_rogues()
          blocked_rogues = await ruckus.get_blocked_rogues()

          
          
          
          ap_stats = await ruckus.get_ap_stats()
          ap_group_stats = await ruckus.get_ap_group_stats()
          
          await ruckus.do_hide_ap_leds("24:79:de:ad:be:ef")
          await ruckus.do_show_ap_leds("24:79:de:ad:be:ef")
          
          await ruckus.do_restart_ap("24:79:de:ad:be:ef")

          
          
          
          vap_stats = await ruckus.get_vap_stats()
          wlan_group_stats = await ruckus.get_wlan_group_stats()
          
          await ruckus.do_disable_wlan("my ssid")
          await ruckus.do_enable_wlan("my ssid")
          
          await ruckus.do_set_wlan_password("my ssid", "blah>blah<")

          
          
          
          all_alarms = await ruckus.get_all_alarms(limit=15)
          
          all_events = await ruckus.get_all_events(limit=1000)
          ap_events = await ruckus.get_ap_events()
          ap_group_events = await ruckus.get_ap_events("24:79:de:ad:be:ef", "24:59:de:ad:be:ef")
          wlan_events = await ruckus.get_wlan_events()
          wlan_group_events = await ruckus.get_wlan_events("my ssid", "my other ssid", "my third ssid")
          client_events = await ruckus.get_client_events(limit=50)
          wired_client_events = await ruckus.get_wired_client_events()
          
          syslog = await ruckus.get_syslog()

          
          
          
          await ruckus.do_add_wlan_group("new empty wlangroup", "empty group added by aioruckus")
          await ruckus.do_add_wlan_group("new full wlangroup", "group added by aioruckus", wlans)
          
          wlan_group_template = next((wlang for wlang in wlan_groups if wlang["name"] == "Default"), None)
          await ruckus.do_clone_wlan_group(wlan_group_template, "Copy of Default")
          
          await ruckus.do_delete_wlan_group("Copy of Default")
          
          await ruckus.do_add_wlan("my new sid", passphrase="mypassphrase" )
          await ruckus.do_edit_wlan("my new sid", {"ofdm-rate-only": True})
          
          template_wlan = next((wlan for wlan in wlans if wlan["name"] == "my ssid"), None)
          await ruckus.do_clone_wlan(template_wlan, "my newer sid")
          await ruckus.do_delete_wlan("my newer sid")

      
      with BackupSession.create("<ruckus backup filename>") as session:
          ruckus = session.api

          aps = await ruckus.get_aps()
          ap_groups = await ruckus.get_ap_groups()
          wlans = await ruckus.get_wlans()
          wlan_groups = await ruckus.get_wlan_groups()
          dpsks = await ruckus.get_dpsks()
          blocked = await ruckus.get_blocked_client_macs()
          mesh = await ruckus.get_mesh_info()
          all_system_info = await ruckus.get_system_info(SystemStat.ALL)

  asyncio.run(test_aioruckus())
  ```



  This project was originally a fork of [pyruckus](https://github.com/gabe565/pyruckus), which provides similar Python query functionality by controlling an SSH CLI session.

  There is a [Go client](https://github.com/willglynn/ruckus-go) for the latest releases of Unleashed.
  Since it's strongly typed, has good quality comments, and doesn't (yet) contain the large collection of tweaks and hacks needed to work over a wide range of Unleashed and ZoneDirector releases, the [ruckus-go](https://github.com/willglynn/ruckus-go) source code is a great place to understand the required requests and responses you should expect to receive from the AJAX API.

  There is also [scrapli](https://github.com/carlmontanari/scrapli) support for the Ruckus Unleashed SSH CLI via [scrapli community](https://github.com/scrapli/scrapli_community).
  Authentication and privilege levels are implemented, but no templates are implemented as of August 2023.


pkgId: fa639b8f3c0a35f103b6b33638f7b6a01cbe554873bc8b9c17d7d812df9a938b
name: python-aiorun
arch: src
version: 2024.8.1
epoch: 0
release: 1
summary: Boilerplate for asyncio applications
url: https://github.com/cjrh/aiorun
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiorun-2024.8.1-1.src.rpm
checksum_type: sha256
description:
  Here's the big idea (how you use it):
     import asyncio
     from aiorun import run
     async def main():
         
         await asyncio.sleep(1.0)
     if __name__ == '__main__':
         run(main())
  This package provides a ``run()`` function as the starting point
  of your ``asyncio``-based application. The ``run()`` function will
  run forever. If you want to shut down when ``main()`` completes, just
  call ``loop.stop()`` inside it: that will initiate shutdown.
      Note that `aiorun.run(coro)` will run **forever**, unlike the standard
      library's ``asyncio.run()`` helper. You can call `aiorun.run()`
      without a coroutine parameter, and it will still run forever.
      This is surprising to many people, because they sometimes expect that
      unhandled exceptions should abort the program, with an exception and
      a traceback. If you want this behaviour, please see the section on
      *error handling* further down.
      Note that `aiorun.run(coro)` will create a **new event loop instance**
      every time it is invoked (same as `asyncio.run`). This might cause
      confusing errors if your code interacts with the default event loop
      instance provided by the stdlib `asyncio` library. For such situations
      you can provide the actual loop you're using with
      `aiorun.run(coro, loop=loop)`. There is more info about this further down.
      However, generally speaking, configuring your own loop and providing
      it in this way is a code smell. You will find it much easier to
      reason about your code if you do all your task creation *inside*
      an async context, such as within an `async def` function, because then
      there will no ambiguity about which event loop is in play: it will
      always be the one returned by `asyncio.get_running_loop()`.


pkgId: cdc126ee062399a4bc5743cdec3e41ce6d766fdb181f1ff0941d86e6d099314a
name: python-aioruuvigateway
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/aioruuvigateway/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioruuvigateway-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Requires Python 3.7 or newer.
  ```console
  pip install aioruuvigateway
  ```

  Ensure you have set up bearer token authentication in your Ruuvi Gateway (and that you know the token).

  Documentation can be found in `test_library.py` for now, sorry.

  You can use the command line interface to test the library.
  ```console
  python -m aioruuvigateway --host 192.168.1.249 --token bearbear --parse --json
  ```
  will output data from the gateway in JSON format, printing changed information every 10 seconds.

  `aioruuvigateway` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: 57c2e4299552be9a406352a7a746947312b808ceabc0a13a5c6a620814ec989f
name: python-aiorwlock
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Read write lock for asyncio.
url: https://github.com/aio-libs/aiorwlock
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiorwlock-1.4.0-1.src.rpm
checksum_type: sha256
description:
  Read write lock for asyncio_ . A ``RWLock`` maintains a pair of associated
  locks, one for read-only operations and one for writing. The read lock may be
  held simultaneously by multiple reader tasks, so long as there are
  no writers. The write lock is exclusive.
  Whether or not a read-write lock will improve performance over the use of
  a mutual exclusion lock depends on the frequency that the data is *read*
  compared to being *modified*. For example, a collection that is initially
  populated with data and thereafter infrequently modified, while being
  frequently searched is an ideal candidate for the use of a read-write lock.
  However, if updates become frequent then the data spends most of its time
  being exclusively locked and there is little, if any increase in concurrency.
  Implementation is almost direct port from this patch_.


pkgId: e136a4e456b00f45a7e3766701a306ff97e878002527d3208310f9ec6fa6afde
name: python-aiosalesforce
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Salesforce REST API client
url: https://github.com/georgebv/aiosalesforce
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosalesforce-0.6.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center" style="font-size:40px; margin:0px 10px 0px 10px">
      <em>⚡ aiosalesforce ⚡</em>
  </p>
  <p align="center">
      <em>Asynchronous Python client for Salesforce APIs</em>
  </p>
  <p align="center">
  <a href="https://github.com/georgebv/aiosalesforce/actions/workflows/test.yml" target="_blank">
      <img src="https://github.com/georgebv/aiosalesforce/actions/workflows/test.yml/badge.svg?event=pull_request" alt="Test">
  </a>
  <a href="https://codecov.io/gh/georgebv/aiosalesforce" target="_blank">
      <img src="https://codecov.io/gh/georgebv/aiosalesforce/graph/badge.svg?token=KVMS7YVODO" alt="Coverage"/>
  </a>
  <a href="https://pypi.org/project/aiosalesforce" target="_blank">
      <img src="https://badge.fury.io/py/aiosalesforce.svg" alt="PyPI Package">
  </a>
  </p>

  **Documentation:** https://georgebv.github.io/aiosalesforce

  **License:** [MIT](https://opensource.org/licenses/MIT)

  **Support:** [ask a question](https://github.com/georgebv/aiosalesforce/discussions)
  or [create an issue](https://github.com/georgebv/aiosalesforce/issues/new/choose),
  any input is appreciated and would help develop the project



  `aiosalesforce` is a modern, production-ready asynchronous Python client
  for Salesforce APIs.
  It is built on top of the `httpx` library and provides a simple and intuitive API
  for interacting with Salesforce's APIs (such as REST and Bulk).

  - **Fast:** designed from the ground up to be fully asynchronous :rocket:
  - **Resilient:** flexible and robust retrying configuration :gear:
  - **Fully typed:** every part of the library is fully typed and annotated :label:
  - **Intuitive:** API follows naming conventions of Salesforce's APIs while
    staying idiomatic to Python :snake:
  - **Salesforce first:** built with years of experience working with the Salesforce API
    it is configured to work out of the box and incorporates best practices and
    latest Salesforce API features :cloud:
  - **Track your API usage:** built-in support for tracking Salesforce API usage
    :chart_with_upwards_trend:

  Supported APIs:

  | API                 | Status | Description                              |
  | ------------------- | ------ | ---------------------------------------- |
  | SOQL Query          | ✅     | Execute SOQL queries                     |
  | sObject             | ✅     | CRUD operations on Salesforce objects    |
  | Composite Batch     | ✅     | Execute multiple independent subrequests |
  | Composite           | ✅     | Execute multiple dependent subrequests   |
  | Composite Graph     | 🕒     | Execute multiple composite graphs        |
  | sObject Tree        | 🕒     | Create one or more sObject trees         |
  | sObject Collections | 🕒     | Execute multiple sObject operations      |
  | Bulk API 1.0        | ❌     | Not planned (use Bulk API 2.0)           |
  | Bulk API 2.0        | ✅     | Bulk ingest and query operations         |



  `aiosalesforce` depends on:

  - Python 3.11+
  - [httpx](https://github.com/encode/httpx)
  - [orjson](https://github.com/ijl/orjson)

  Optional dependencies:

  - [PyJWT](https://github.com/jpadilla/pyjwt)
  - [cryptography](https://github.com/pyca/cryptography)



  ```shell
  pip install aiosalesforce
  ```

  To use the JWT Bearer Flow authentication install with the `jwt` extra:

  ```shell
  pip install aiosalesforce[jwt]
  ```



  Example below shows how to:

  - Authenticate against Salesforce using the SOAP login method
  - Create a Salesforce client
  - Create a new Contact
  - Read a Contact by ID
  - Execute a SOQL query

  ```python
  import asyncio

  from aiosalesforce import Salesforce
  from aiosalesforce.auth import SoapLogin
  from httpx import AsyncClient


  auth = SoapLogin(
      username="your-username",
      password="your-password",
      security_token="your-security-token",
  )

  async def main():
      async with AsyncClient() as client:
          
          salesforce = Salesforce(
              client,
              base_url="https://your-instance.my.salesforce.com",
              auth=auth,
          )

          
          contact_id = await salesforce.sobject.create(
              "Contact",
              {
                  "FirstName": "John",
                  "LastName": "Doe",
                  "Email": "john.doe@example.com",
              },
          )
          print(f"Created Contact with ID: {contact_id}")

          
          contact = await salesforce.sobject.get("Contact", contact_id)
          print(contact)

          
          async for record in salesforce.query("SELECT Id, Name FROM Contact"):
              print(record)


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

rpm_license:
  Copyright 2024 Georgii Bocharov  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.


pkgId: 2ba944a081d1b61c6ca2844cf48dca963a2821a0bfdba4f248804336d3b0662d
name: python-aiosched
arch: src
version: 0.0.25
epoch: 0
release: 1
summary: asyncio job scheduler
url: https://github.com/alttch/aiosched
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosched-0.0.25-1.src.rpm
checksum_type: sha256
description:
  Executes specified asyncio jobs with a chosen interval. Has relatively small
  number of features but it's fast.

  <img src="https://img.shields.io/pypi/v/aiosched.svg" /> <img src="https://img.shields.io/badge/license-MIT-green" /> <img src="https://img.shields.io/badge/python-3.5%20%7C%203.6%20%7C%203.7-blue.svg" />



  * it's extremely accurate and fast
  * it's simple
  * all methods are thread-safe



  ```python
  from aiosched import scheduler
  import asyncio

  async def test1(a, b, c):
      print(f'JOB1 {a} {b} {c}')

  async def test2():
      print('JOB2')

  async def test3():
      print('JOB3')

  from aiosched import scheduler

  loop = asyncio.new_event_loop()
  scheduler.start(loop=loop)

  job1 = scheduler.create_threadsafe(target=test1, args=(1, 2, 3), interval=1)
  job2 = scheduler.create_threadsafe(target=test2, interval=0.5)

  job3 = scheduler.create_threadsafe(target=test3, number=1, timer=5)

  scheduler.cancel(job2)

  job2.cancel()

  loop.run_forever()
  ```

  or run scheduler loop as coroutine:

  ```python
  loop = asyncio.new_event_loop()
  job1 = scheduler.create_threadsafe(target=test1, args=(1,2,3), interval=0.1)
  job2 = scheduler.create_threadsafe(target=test2, interval=0.1)
  loop.run_until_complete(scheduler.scheduler_loop())
  ```



  ```shell
  pip3 install aiosched
  ```



  Read **AsyncJobScheduler** and **AsyncScheduledJob** classes documentation in
  pydoc.


pkgId: 091b7cebfb17801fb06962166a7e46e35e12107fbe3016e522024143463d0485
name: python-aioschedule
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Job scheduling for humans.
url: https://github.com/ibrb/python-aioschedule
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioschedule-0.5.2-1.src.rpm
checksum_type: sha256
description:
  Python job scheduling for humans. Forked and modified from github.com/dbader/schedule.
  An in-process scheduler for periodic jobs that uses the builder pattern
  for configuration. Schedule lets you run Python functions (or any other
  callable) periodically at pre-determined intervals using a simple,
  human-friendly syntax.
  Inspired by `Adam Wiggins' <https://github.com/adamwiggins>`_ article `"Rethinking Cron" <https://adam.herokuapp.com/past/2010/4/13/rethinking_cron/>`_ and the `clockwork <https://github.com/Rykian/clockwork>`_ Ruby module.


pkgId: 08f1895f3466653e85611f6dd5ff446d2f08225d8731cd7432da515eba130dab
name: python-aioscheduler
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Scalable, high-performance AsyncIO task scheduler
url: https://github.com/Gelbpunkt/aioscheduler
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioscheduler-1.4.2-1.src.rpm
checksum_type: sha256
description:
  aioscheduler is a scalable and high-performance task scheduler for asyncio.

  It schedules execution of coroutines at a specific time in a single task, making it lightweight and extremely scalable by adding a manager for multiple schedulers.

  Tests have shown that aioscheduler can run up to 10 million timed tasks with up to 20 finishing per second when using 20 schedulers. Single tasks can easily schedule up to 10.000 tasks. This is based on tests on a Xeon E5 1650v3.



  `pip install aioscheduler`



  aioscheduler provides several Scheduler classes that runs a main task to consume coroutines.

  There are `QueuedScheduler/LifoQueuedScheduler` and `TimedScheduler`, whereas TimedScheduler is the default for Managers.

  The TimedScheduler compares datetime objects to UTC by default, to disable it, pass `prefer_utc=False` to the constructor.

  ```py
  import asyncio
  from datetime import datetime, timedelta
  from aioscheduler import TimedScheduler

  async def work(n: int) -> None:
      print(f"I am doing heavy work: {n}")

  async def main() -> None:
      starting_time = datetime.utcnow()
      scheduler = TimedScheduler()
      scheduler.start()

      for i in range(60):
          scheduler.schedule(work(i), starting_time + timedelta(seconds=5 + i))

      await asyncio.sleep(65)

  asyncio.run(main())
  ```

  In this example, 60 tasks are scheduled to run in 5 seconds from now, 1 of them per second over a time of 1 minute.

  The QueuedScheduler works identical, but consumes tasks in scheduling order immediately and only takes a single coroutine as argument to `schedule()`.

  To scale even further, aioscheduler offers the Manager (example with QueuedScheduler backend):

  ```py
  import asyncio
  from datetime import datetime, timedelta
  from aioscheduler import Manager, QueuedScheduler

  async def work(n: int) -> None:
      print(f"I am doing heavy work: {n}")

  async def main() -> None:
      starting_time = datetime.utcnow()
      manager = Manager(5, cls=QueuedScheduler)  # The number of Schedulers to use
                                                 
      manager.start()

      for i in range(30000):
          manager.schedule(work(i))

      await asyncio.sleep(5)

  asyncio.run(main())
  ```

  The manager distributes the tasks across multiple schedulers internally and acts as a load-balancer.

  `schedule()` returns a Task object, you may cancel a task after scheduling by running `scheduler.cancel(task)` (or `manager.cancel(task)`). The manager is less efficient for cancelling.

  To limit the amount of tasks scheduled, there is a `max_tasks` argument that takes a positive integer. It is advised to use this in production enviroments of known task queue sizes and available on both Scheduler and Manager.



  MIT


pkgId: fb8909d52641c8a0210c679a3dad2c2a07edb0857764817befc72fea9029cedc
name: python-aioschluter
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Async Python wrapper for the Schluter-DITRA-E-WIFI thermostats API.
url: https://github.com/IngoS11/aioschluter
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioschluter-0.1.9-1.src.rpm
checksum_type: sha256
description:
  An async Python wrapper for the [Schluter-DITRA-E-WIFI](https://www.schluter.com/schluter-us/en_US/ditra-heat-wifi) Wi-Fi Themostat



  Create a user for your thermostats at [https://ditra-heat-e-wifi.schluter.com/](https://ditra-heat-e-wifi.schluter.com/)



  Install the most recent version of the library from [Python Package Index](https://pypi.org/project/aioschluter/)

  ```
  pip install aioschluter
  ```



  ```python
  import asyncio
  import logging

  from aiohttp import ClientError, ClientSession

  from aioschluter import (
      ApiError,
      InvalidUserPasswordError,
      InvalidSessionIdError,
      SchluterApi,
  )



  SCHLUTER_USERNAME = "XXXX"
  SCHLUTER_PASSWORD = "XXXX"

  logging.basicConfig(level=logging.DEBUG)


  async def main():
      async with ClientSession() as websession:
          try:
              schluter = SchluterApi(websession)

              sessionid = await schluter.async_get_sessionid(
                  SCHLUTER_USERNAME, SCHLUTER_PASSWORD
              )
              thermostats = await schluter.async_get_current_thermostats(sessionid)
          except (
              ApiError,
              ClientError,
              InvalidUserPasswordError,
              InvalidSessionIdError,
          ) as error:
              print(f"Error: {error}")
          else:
              for thermostat in thermostats.values():
                  print(thermostat)


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


pkgId: e8b8b07e04661befd2f0354ec611e966b854769dbf8bc7395707470e26d37300
name: python-aioscrapy
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Python asynchronous library for web scraping
url: https://github.com/eugen1j/aioscrapy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioscrapy-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/aioscrapy.svg)](https://badge.fury.io/py/aioscrapy)
  [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/eugen1j/aioscrapy/blob/master/LICENSE)

  [![Build Status](https://api.travis-ci.com/eugen1j/aioscrapy.svg?branch=master)](https://travis-ci.com/github/eugen1j/aioscrapy)
  [![codecov](https://codecov.io/gh/eugen1j/aioscrapy/branch/master/graph/badge.svg)](https://codecov.io/gh/eugen1j/aioscrapy)
  [![codebeat badge](https://codebeat.co/badges/c494c251-c554-4f61-be57-6ca484ae7ba9)](https://codebeat.co/projects/github-com-eugen1j-aioscrapy-master)
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/54e3d1b41bed4c9fb62e25483d1fe1eb)](https://www.codacy.com/app/eugen1j/aioscrapy?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=eugen1j/aioscrapy&amp;utm_campaign=Badge_Grade)



      pip install aioscrapy



  Plain text scraping
  ```python
  import asyncio
  import json

  from aioscrapy import Client, WebTextClient, SingleSessionPool, Dispatcher, SimpleWorker


  class CustomClient(Client[str, dict]):
      def __init__(self, client: WebTextClient):
          self._client = client

      async def fetch(self, key: str) -> dict:
          data = await self._client.fetch(key)
          return json.loads(data)


  async def main():
      pool = SingleSessionPool()
      dispatcher = Dispatcher(['https://httpbin.org/get'])
      client = CustomClient(WebTextClient(pool))
      worker = SimpleWorker(dispatcher, client)

      result = await worker.run()
      return result

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

  Byte content downloading
  ```python
  import asyncio

  from aioscrapy import Client, WebByteClient, SingleSessionPool, Dispatcher, SimpleWorker


  class CustomClient(Client[str, bytes]):
      def __init__(self, client: WebByteClient):
          self._client = client

      async def fetch(self, key: str) -> bytes:
          data = await self._client.fetch(key)
          return data


  async def main():
      pool = SingleSessionPool()
      dispatcher = Dispatcher(['https://httpbin.org/image'])
      client = CustomClient(WebByteClient(pool))
      worker = SimpleWorker(dispatcher, client)

      result = await worker.run()
      return result

  loop = asyncio.get_event_loop()
  data: dict = loop.run_until_complete(main())
  for url, byte_content in data.items():
      print(url + ": " + str(len(byte_content)) + " bytes")
  ```


pkgId: e5310cfa7b4da8d34109be4d7db756aecb6aba15b0f58eca5103557012169a6f
name: python-aioscryfall
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Asynchronous Python client for the Scryfall API
url: https://github.com/gwax/aioscryfall
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioscryfall-0.4.2-1.src.rpm
checksum_type: sha256
description:
  aioscryfall is a Python client for the Scryfall API. It is primarily designed for asynchronous use with asyncio, but a synchronous client is also provided.
  The development is essentially feature complete but the documentation is largely absent, at present. (I need to remind myself how mkdocs works and figure out what I want to say)
  As of right now, Python 3.11 is required because I wanted to use a number of typing features that were added in 3.11. I may change this in the future, but it is a lower priority than getting the API to a point where I am happy with it.
  Everything is extensively typed and I have tried to make the API as intuitive as possible. I have also tried to make the API as close to the Scryfall API as possible, but I have made some changes to make it more Pythonic (namely converting paginated lists into iterable generators).
  A minimal use case to get yourself started:
      import asyncio
      import aiohttp
      from aioscryfall.api.cards import UniqueMode
      from aioscryfall.client import ScryfallClient
      async def get_bolt():
          async with aiohttp.ClientSession() as session:
              client = ScryfallClient(session)
              bolts = [c async for c in client.cards.search("lightning bolt", unique=UniqueMode.PRINTS)]
              return bolts
      bolts = asyncio.run(get_bolt())
      print(len(bolts), bolts[0])
  Or if you prefer not to use async:
      from aioscryfall.api.cards import UniqueMode
      from aioscryfall.sync.client import ScryfallSyncClient
      client = ScryfallSyncClient()
      bolts = list(client.cards.search("lightning bolt", unique=UniqueMode.PRINTS))
      print(len(bolts), bolts[0])


pkgId: cbf8c29e8102105196078017c3e1e19938e67ecfa70714b71269a27749ffd2d2
name: python-aiosenz
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Async Typed Python package for the nVent RAYCHEM SENZ RestAPI
url: https://github.com/milanmeu/aiosenz
rpm_license: LGPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosenz-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/aiosenz)](https://pypi.org/project/aiosenz) ![PyPI - Downloads](https://img.shields.io/pypi/dm/aiosenz) [![PyPI - License](https://img.shields.io/pypi/l/aiosenz?color=blue)](https://github.com/milanmeu/aiosenz/blob/main/COPYING)

  An async Python wrapper for the nVent Raychem SENZ RestAPI.


  ```bash
  pip install aiosenz
  ```


  This package offers an `AbstractSENZAuth`, where you should handle the OAuth2 tokens and provide a valid access token in `get_access_token()`. You can use `SENZAuth` if you don't want to handle the OAuth2 tokens yourself.



  `SENZAuth` uses the Authorization Code grant type. This requires a Client ID and Client Secret, more information is available in [the RestAPI documentation](https://api.senzthermostat.nvent.com).


  AioSENZ uses the `restapi` and `offline_access` scope, this is set as default in SENZAuth and should be set in the OAuth2 client if you are using the AbstractSENZAuth class. The OpenID (`openid`) and OpenID Profile (`profile`) scopes are not supported, because nVent recommends to use the RestAPI Account instead.


  ```python
  from asyncio import run
  from aiosenz import SENZAuth, SENZAPI
  import httpx

  async def main():
      async with httpx.AsyncClient() as httpx_client:
          senz_auth = SENZAuth(
              httpx_client,
              "YOUR_CLIENT_ID",
              "YOUR_CLIENT_SECRET",
              redirect_uri="http://localhost:8080/auth/callback",
          )
          uri, state = await senz_auth.get_authorization_url()
          print("Authorization URI: ", uri)
          authorization_response = input("The authorization response URL: ")
          await senz_auth.set_token_from_authorization_response(authorization_response)

          senz_api = SENZAPI(senz_auth)
          thermostats = await senz_api.get_thermostats()
          for thermostat in thermostats:
              print(f"{thermostat.name} temperature: {thermostat.current_temperatue}")
          await senz_auth.close()

  run(main())
  ```


pkgId: 849f43ccdc14fc003fa00d30ef535b48e28336188f3bc655bd972d33a78c383f
name: python-aioserial
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: An asynchronous serial port library of Python
url: https://github.com/changyuheng/aioserial.py
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioserial-1.3.1-1.src.rpm
checksum_type: sha256
description:
  * [Quick start](#quick-start)
      + [A simple serial port reader](#a-simple-serial-port-reader)
      + [pyserial-asyncio example replacement](#pyserial-asyncio-example-replacement)
  * [API](#api)
      + [AioSerial](#aioserial)
          - [Constructor](#constructor)
          - [Methods](#methods)
              * [read_async](#read-async)
              * [read_until_async](#read-until-async)
              * [readinto_async](#readinto-async)
              * [readline_async](#readline-async)
              * [readlines_async](#readlines-async)
              * [write_async](#write-async)
              * [writelines_async](#writelines-async)
      + [Other APIs](#other-apis)
  * [Why aioserial?](#why-aioserial-)

  A Python package that combines [asyncio](https://docs.python.org/3/library/asyncio.html) and [pySerial](https://pypi.org/project/pyserial/).





  ```py
  import asyncio

  import aioserial


  async def read_and_print(aioserial_instance: aioserial.AioSerial):
      while True:
          print((await aioserial_instance.read_async()).decode(errors='ignore'), end='', flush=True)

  asyncio.run(read_and_print(aioserial.AioSerial(port='COM1')))
  ```



  **The example usage from pyserial-asyncio**

  https://pyserial-asyncio.readthedocs.io/en/latest/shortintro.html

  ```py
  import asyncio
  import serial_asyncio

  class Output(asyncio.Protocol):
      def connection_made(self, transport):
          self.transport = transport
          print('port opened', transport)
          transport.serial.rts = False  # You can manipulate Serial object via transport
          transport.write(b'Hello, World!\n')  # Write serial data via transport

      def data_received(self, data):
          print('data received', repr(data))
          if b'\n' in data:
              self.transport.close()

      def connection_lost(self, exc):
          print('port closed')
          self.transport.loop.stop()

      def pause_writing(self):
          print('pause writing')
          print(self.transport.get_write_buffer_size())

      def resume_writing(self):
          print(self.transport.get_write_buffer_size())
          print('resume writing')

  loop = asyncio.get_event_loop()
  coro = serial_asyncio.create_serial_connection(loop, Output, '/dev/ttyUSB0', baudrate=115200)
  loop.run_until_complete(coro)
  loop.run_forever()
  loop.close()
  ```

  **aioserial equivalence**

  ```py
  import asyncio

  import aioserial


  async def read_and_print(aioserial_instance: aioserial.AioSerial):
      while True:
          data: bytes = await aioserial_instance.read_async()
          print(data.decode(errors='ignore'), end='', flush=True)
          if b'\n' in data:
              aioserial_instance.close()
              break

  aioserial_instance: aioserial.AioSerial = aioserial.AioSerial(port='/dev/ttyUSB0', baudrate=115200)
  asyncio.run(asyncio.gather(read_and_print(aioserial_instance), aioserial_instance.write_async(b'Hello, World!\n')))
  ```





  ```py
  >>> import aioserial
  >>> import serial

  >>> isinstance(aioserial.AioSerial(), serial.Serial)
  True

  >>> issubclass(aioserial.AioSerial, serial.Serial)
  True

  >>> aioserial.Serial is serial.Serial
  True
  ```



  ```py
  aioserial_instance: aioserial.AioSerial = aioserial.AioSerial(
      
      loop: Optional[asyncio.AbstractEventLoop] = None,
      cancel_read_timeout: int = 1,
      cancel_write_timeout: int = 1)
  ```






  ```py
  bytes_read: bytes = \
      await aioserial_instance.read_async(size: int = 1)
  ```



  ```py
  at_most_certain_size_of_bytes_read: bytes = \
      await aioserial_instance.read_until_async(
          expected: bytes = aioserial.LF, size: Optional[int] = None)
  ```



  ```py
  number_of_byte_read: int = \
      await aioserial_instance.readinto_async(b: Union[array.array, bytearray])
  ```



  ```py
  a_line_of_at_most_certain_size_of_bytes_read: bytes = \
      await aioserial_instance.readline_async(size: int = -1)
  ```



  ```py
  lines_of_at_most_certain_size_of_bytes_read: bytes = \
      await aioserial_instance.readlines_async(hint: int = -1)
  ```



  ```py
  number_of_byte_like_data_written: int = \
      await aioserial_instance.write_async(bytes_like_data)
  ```



  ```py
  number_of_byte_like_data_in_the_given_list_written: int = \
      await aioserial_instance.writelines_async(list_of_bytes_like_data)
  ```



  All the other APIs in the mother package [pySerial](https://pypi.org/project/pyserial/) are supported in aioserial as-is.



  * Want to use an asyncio-based but not a (self-built) thread-based serial library.
  * [pySerial-asyncio](https://pypi.org/project/pyserial-asyncio/) does [not support Windows](https://github.com/pyserial/pyserial-asyncio/issues/3).
  * APIs in all the other packages ([pySerial-asyncio](https://pypi.org/project/pyserial-asyncio/),
      [asyncserial](https://pypi.org/project/asyncserial/)) that target the same goal are not designed in high level.


pkgId: 58c9c058172729ea5ce6b3a2afd7c82e46bdb3df44e01c596dc3e7c807eab2e2
name: python-aioserver
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: An async web framework for humans
url: https://github.com/divbzero/aioserver
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioserver-0.7.3-1.src.rpm
checksum_type: sha256
description:
  ```
  pip install aioserver
  ```

  Start a test server with the examples in the **Usage** section below:
  ```
  make test
  ```
  Make requests against the running test server:
   ```
  curl -v localhost:8080
  curl -v localhost:8080/found
  curl -v localhost:8080/not-found
  curl -v localhost:8080/server-error
   ```


pkgId: 8e22941d3ebb0c2872d212a0e91d1495dd78a9d37bfdd5c01f23afa5c0d05e03
name: python-aiosfstream
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Salesforce Streaming API client for asyncio
url: https://github.com/robertmrk/aiosfstream
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosfstream-0.5.0-1.src.rpm
checksum_type: sha256
description:
  aiosfstream is a `Salesforce Streaming API <api_>`_ client for asyncio_. It can
  be used to receive push notifications about changes on Salesforce objects or
  notifications of general events sent through the `Streaming API <api_>`_.
  For detailed guidance on how to work with `PushTopics <PushTopic_>`_ or how
  to create `Generic Streaming Channels <GenericStreaming_>`_ please consult the
  `Streaming API documentation <api_>`_.
  For working with `Platform Events <PlatformEvents_>`_ or
  `Change Data Capture events <ChangeDataCapture_>`_ check out the linked
  documentation.


pkgId: 65defb75ba5f78522ddab5478c206d12ad00262003b92dfee1c3f1319cda0ea2
name: python-aioshelly
arch: src
version: 12.0.0
epoch: 0
release: 1
summary: Asynchronous library to control Shelly devices.
url: https://github.com/home-assistant-libs/aioshelly
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioshelly-12.0.0-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/home-assistant-libs/aioshelly/graph/badge.svg?token=DDH79OVIQ0)](https://codecov.io/gh/home-assistant-libs/aioshelly)
  [![ci](https://img.shields.io/github/actions/workflow/status/home-assistant-libs/aioshelly/test.yml?branch=main&label=CI&logo=github&style=flat-square)](https://github.com/home-assistant-libs/aioshelly/actions/workflows/test.yml?query=branch%3Amain)



  Asynchronous library to control Shelly devices

  **This library is under development**



  - Python >= 3.11
  - bluetooth-data-tools
  - aiohttp
  - orjson


  ```bash
  pip install aioshelly
  ```


  Run the following command inside this folder
  ```bash
  pip install --upgrade .
  ```




  ```python
  import asyncio
  from pprint import pprint

  import aiohttp

  from aioshelly.block_device import COAP, BlockDevice
  from aioshelly.common import ConnectionOptions
  from aioshelly.exceptions import DeviceConnectionError, InvalidAuthError


  async def test_block_device():
      """Test Gen1 Block (CoAP) based device."""
      options = ConnectionOptions("192.168.1.165", "username", "password")

      async with aiohttp.ClientSession() as aiohttp_session, COAP() as coap_context:
          try:
              device = await BlockDevice.create(aiohttp_session, coap_context, options)
          except InvalidAuthError as err:
              print(f"Invalid or missing authorization, error: {repr(err)}")
              return
          except DeviceConnectionError as err:
              print(f"Error connecting to {options.ip_address}, error: {repr(err)}")
              return

          for block in device.blocks:
              print(block)
              pprint(block.current_values())
              print()


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



  ```python
  import asyncio
  from pprint import pprint

  import aiohttp

  from aioshelly.common import ConnectionOptions
  from aioshelly.exceptions import DeviceConnectionError, InvalidAuthError
  from aioshelly.rpc_device import RpcDevice, WsServer


  async def test_rpc_device():
      """Test Gen2/Gen3 RPC (WebSocket) based device."""
      options = ConnectionOptions("192.168.1.188", "username", "password")
      ws_context = WsServer()
      await ws_context.initialize(8123)

      async with aiohttp.ClientSession() as aiohttp_session:
          try:
              device = await RpcDevice.create(aiohttp_session, ws_context, options)
          except InvalidAuthError as err:
              print(f"Invalid or missing authorization, error: {repr(err)}")
              return
          except DeviceConnectionError as err:
              print(f"Error connecting to {options.ip_address}, error: {repr(err)}")
              return

          pprint(device.status)


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



  The repository includes example script to quickly try it out.



  ```
  python3 tools/example.py -ip <ip> [-u <username>] [-p <password] -i
  ```



  ```
  python3 tools/example.py -d -i
  ```

  ```
  python3 tools/example.py -h
  ```



  Object hierarchy and property/method names should match the [Shelly API](https://shelly-api-docs.shelly.cloud/).


pkgId: 2c071b5c27ae96fdfc88c8dd54f95bcccf066732efe241af86ce0b1b56606df0
name: python-aioshutil
arch: src
version: 1.5
epoch: 0
release: 1
summary: Asynchronous shutil module.
url: https://github.com/kumaraditya303/aioshutil
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioshutil-1.5-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/aioshutil)](https://pepy.tech/project/aioshutil) ![](https://img.shields.io/pypi/v/aioshutil)  ![](https://img.shields.io/pypi/pyversions/aioshutil) ![](https://img.shields.io/pypi/implementation/aioshutil)



  `aioshutil` is a Python library which provides asynchronous version of function of shutil module. `shutil` module is blocking and using it in asyncio applications will block the event loop and slow down the application, `aioshutil` provides asynchronous friendly versions of the functions of the `shutil` module as it performs blocking io in a thread pool.



  ```console
  $ pip install aioshutil
  ```



  The API of `aioshutil` module is same as `shutil` module except that it is asynchronous.

  ```python
  from aioshutil import rmtree
  await rmtree("/tmp")
  ```

  `aioshutil` provides the following functions:

  - `copyfileobj`
  - `copyfile`
  - `copymode`
  - `copystat`
  - `copy`
  - `copy2`
  - `copytree`
  - `move`
  - `rmtree`
  - `make_archive`
  - `get_archive_formats`
  - `register_archive_format`
  - `unregister_archive_format`
  - `get_unpack_formats`
  - `register_unpack_format`
  - `unregister_unpack_format`
  - `unpack_archive`
  - `ignore_patterns`
  - `chown`
  - `which`
  - `get_terminal_size`

  `aioshutil` provides the following exceptions for consistency with `shutil` module:

  - `Error`
  - `SpecialFileError`
  - `ExecError`
  - `SameFileError`


pkgId: a018570640874db3130c99803204ad1d6219aca6c46edf3398976789ccdecdd4
name: python-aiosignald
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: Python bindings for signald
url: https://git.sr.ht/~nicoco/aiosignald
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosignald-0.3.7-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://badge.fury.io/py/aiosignald.svg)](https://pypi.org/project/aiosignald/)
  [![Documentation Status](https://readthedocs.org/projects/aiosignald/badge/?version=latest)](https://aiosignald.readthedocs.io/en/latest/)
  [![builds.sr.ht status](https://builds.sr.ht/~nicoco/aiosignald/commits/master/.build.yml.svg)](https://builds.sr.ht/~nicoco/aiosignald/commits/master/.build.yml?)
  Interact with the signal messaging network in python with sweet, sweet autocompletion.
  Most of the code is generated by the `generate.py` script that
  uses the schema available at <https://signald.org/protocol.json>.
  No 3rd party dep, just the python standard lib.


pkgId: 29cac7a270f11f31620bad27c1f33ae7da9e45bca174c112797450100a86b4e8
name: python-aioskybell
arch: src
version: 23.12.0
epoch: 0
release: 1
summary: A Skybell HD Python library running on Python 3.
url: https://github.com/tkdrob/aioskybell
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioskybell-23.12.0-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/tkdrob/aioskybell/branch/master/graph/badge.svg)](https://codecov.io/gh/tkdrob/aioskybell)
  ![python version](https://img.shields.io/badge/Python-3.9=><=3.12-blue.svg)
  [![PyPI](https://img.shields.io/pypi/v/aioskybell)](https://pypi.org/project/aioskybell)
  ![Actions](https://github.com/tkdrob/aioskybell/workflows/Actions/badge.svg?branch=master)

  _Python API client for Skybell Doorbells._



  ```bash
  python3 -m pip install aioskybell
  ```



  More examples can be found in the `tests` directory.

  ```python
  """Example usage of aioskybell."""
  import asyncio
  from aioskybell import Skybell


  async def async_example():
      """Example usage of aioskybell."""
      async with Skybell(username="user", password="password") as client:
          print(await client.async_initialize())

  asyncio.get_event_loop().run_until_complete(async_example())
  ```



  **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 `master` branch


pkgId: 9249c12e33e696b0c5081996841feb0c9b078aacdd04779aac4bee34c90c3b24
name: python-aioslimproto
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Python module to talk to Logitech Squeezebox players directly (without Logitech server).
url: https://pypi.org/project/aioslimproto/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioslimproto-3.1.0-1.src.rpm
checksum_type: sha256
description:
  [![pypi_badge](https://img.shields.io/pypi/v/aioslimproto.svg)](https://pypi.python.org/pypi/aioslimproto)
  **AIOSlimProto**
  SLIMProto implementation in async python allows you to control squeezebox players (and compatibles).
  Requires Python 3.11+ and uses asyncio.
  For simple usage examples, see the example script in the scripts folder.
  For a full reference implementation, see [Home Assistant](https://github.com/home-assistant/core/tree/dev/homeassistant/components/slimproto) and [Music Assistant](https://github.com/music-assistant/server/tree/main/music_assistant/server/providers/slimproto)


pkgId: 118347243294e28cfae573a475a3a5bd912fd1bd39904f83011f440dbd0fd936
name: python-aioslurm
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: aioslurm.
url: https://gitlab.com/aioslurm/aioslurm
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioslurm-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![pipeline status](https://gitlab.com/aioslurm/aioslurm/badges/development/pipeline.svg)](https://gitlab.com/aioslurm/aioslurm/commits/development) [![coverage](https://gitlab.com/aioslurm/aioslurm/badges/development/coverage.svg)](https://aioslurm.gitlab.io/aioslurm/coverage/)


  Documentation: https://aioslurm.gitlab.io/aioslurm/




  Docker (compose) is used both for development and for GitLab CI to ensure a
  consistent environment.


  Get started by cloning the repository and work on the `development` branch:

  ```bash
  git clone git@gitlab.com:aioslurm/aioslurm.git
  cd aioslurm
  ```




  `docker` and `fabric` (v2+) should be installed and available locally to
  build/run the containers. On Ubuntu 22.04+, you can install these with:

  ```bash
  sudo apt install docker fabric
  ```

  To build the docker containers:

  ```bash
  fab build
  ```




  Remember to run the tests locally when developing to catch failures before CI
  is run on push to the repo.

  Run tests:

  ```bash
  fab tox
  ```




  Generate docs:

  ```bash
  fab docs
  ```

  Python shell:

  ```bash
  fab shell
  ```

  Bash shell:

  ```bash
  fab bash
  ```


pkgId: c67440707f5d7df91f626cf552d1e3c7c6f7f19ffa7d93ff5347ec0366831089
name: python-aiosmpplib
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Python asyncio SMPP client library.
url: https://github.com/niksabaldun/aiosmpplib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosmpplib-0.7.0-1.src.rpm
checksum_type: sha256
description:
  An asynchronous SMPP library for use with asyncio.
  Inspired by `naz`_ library by Komu Wairagu. Initial intention was to add missing functionality
  to existing library. But in the end, the code has been almost completely rewritten and released
  as a separate library.
      SMPP is a protocol designed for the transfer of short message data between External Short
      Messaging Entities(ESMEs), Routing Entities(REs) and Short Message Service Center(SMSC).
      - `Wikipedia <https://en.wikipedia.org/wiki/Short_Message_Peer-to-Peer>`_
  Currently, only partial ESME functionality is implemented, and only SMPP version 3.4 is supported.
  > :warning: **Version 0.7.0 introduces breaking changes to Correlator, due to implementation of message segmentation.**
  Full documentation is not available at this time.


pkgId: 6682f8d56222ab17d84cdaeda424442b51c26198977a9cb4ce3985ada2477e15
name: python-aiosnow
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Asynchronous Python ServiceNow library
url: https://github.com/rbw/aiosnow
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosnow-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![image](https://badgen.net/pypi/v/aiosnow)](https://pypi.org/project/aiosnow)
  [![image](https://badgen.net/badge/python/3.7+?color=purple)](https://pypi.org/project/aiosnow)
  [![image](https://badgen.net/travis/rbw/aiosnow)](https://travis-ci.org/rbw/aiosnow)
  [![image](https://badgen.net/pypi/license/aiosnow)](https://raw.githubusercontent.com/rbw/aiosnow/master/LICENSE)
  [![image](https://pepy.tech/badge/snow/month)](https://pepy.tech/project/snow)

  **aiosnow** is a Python [asyncio](https://docs.python.org/3/library/asyncio.html) library for interacting with ServiceNow programmatically. It hopes to be:

  - Convenient: A good deal of work is put into making the library flexible and easy to use.
  - Performant: Uses non-blocking I/O to allow large amounts of API request tasks to run concurrently while being friendly on system resources.
  - Modular: Core functionality is componentized into modules that are built with composability and extensibility in mind.

  *Example code*

  ```python
  import asyncio

  import aiosnow
  from aiosnow.models.table.declared import IncidentModel as Incident

  async def main():
      client = aiosnow.Client("<instance>.service-now.com", basic_auth=("<username>", "<password>"))

      async with Incident(client, table_name="incident") as inc:
          
          for response in await inc.get(Incident.priority <= 3, limit=5):
              print(f"Number: {response['number']}, Priority: {response['priority'].value}")

  asyncio.run(main())
  ```

  Check out the [examples directory](examples) for more material.



  API reference and more is available in the [technical documentation](https://aiosnow.readthedocs.io/en/latest).




  The **aiosnow** code is permissively licensed, and can be incorporated into any type of application–commercial or otherwise–without costs or limitations.
  Its author believes it's in the commercial best-interest for users of the project to invest in its ongoing development.

  Consider leaving a [donation](https://paypal.vault13.org) if you like this software, it will:

  - Directly contribute to faster releases, more features, and higher quality software.
  - Allow more time to be invested in documentation, issue triage, and community support.
  - Safeguard the future development of **aiosnow**.



  Beta: Core functionality is done and API breakage unlikely to happen.




  Check out the [contributing guidelines](CONTRIBUTING.md) if you want to help out with code or documentation.




  Robert Wikman \<rbw@vault13.org\>


pkgId: 06f05c708ed9cbc4e195479606dc7130e6758e4f4c228bc4c7a9bc7556055743
name: python-aiosolaredge
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Asyncio SolarEdge
url: https://github.com/bdraco/aiosolaredge
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosolaredge-0.2.0-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://aiosolaredge.readthedocs.io" target="_blank">https://aiosolaredge.readthedocs.io </a>


pkgId: b5871f2b768a41aac67a4ba4e7ad534c2272ad5e54f72be9f02a82b6dc849cc3
name: python-aiosolr
arch: src
version: 5.0.2
epoch: 0
release: 1
summary: Lightweight AsyncIO Python client for Apache Solr
url: https://pypi.org/project/aiosolr/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosolr-5.0.2-1.src.rpm
checksum_type: sha256
description:
  AsyncIO Python client for Apache Solr



  This project requires Python 3.7+



  To install with pip

      pip install aiosolr



  The connection to the Solr backend is defined during object initialization. The accepted kwargs to
  init are `scheme`, `host`, `port`, and `collection`.

  > `collection` may optionally be passed at query time

  ```python
  import aiosolr

  client = aiosolr.Client(host=localhost, collection="example", port=8983)
  ```

  Alternatively you may instantiate via passing `connection_url` like:

  ```python
  import aiosolr

  client = aiosolr.Client(connection_url="http://host:1234/path/to/solr/collection")
  ```

  Once you have your `aiosolr.Client` instance, set up the session:

  ```python
  await client.setup()
  ```

  There are methods available for querying. You can use Solr's built-in get handler with the `get`
  method to retrieve a single document:

  ```python
  await client.get(document_id)
  ```

  You can use a pre-defined suggestions handler by using the `suggestions` method:

  ```python
  await client.suggestions("suggest_handler", query="asdf")
  ```

  You can also use the `suggestions` method to build your suggestions:

  ```python
  await client.suggestions("suggest_handler", build=True)
  ```

  > `handler` is a required argument for suggestions unlike for get or query

  You can use the `query` method to query your search handler. The default `handler` used is `select`.
  If you would like spellcheck suggestion turned on, pass `spellcheck=True` (default is `False`).

  ```python
  await client.query(handler="my_handler", query="asdf", spellcheck=True)
  ```

  If `spellcheck` is `True` the query method returns a tuple with the first element being an array of
  documents and the 2nd element being an array of spellcheck suggestions. Otherwise, the query method
  returns a simple array of documents.

  You can use the `update` method to access Solr's built-in update handler like:

  ```python
  await client.update(my_data)
  ```

  At any point that you need to commit data to your collection you can use the `commit` method.
  Arguments should be the `handler` (`update` by default) and `soft` as a boolean indicating whether
  it should be a hard or soft commit (defaults to `False`).

  There is one more method you might want to use before querying Solr especially if the query is
  coming from an untrusted end user. There is a `clean_query` method which can be used to strip out
  unwanted characters. Use it like:

  ```python
  trusted_query = aiosolr.clean_query(users_query)
  ```

  Once you are finished with the Solr instance, you should call the method `close` to cleanup sessions
  like:

  ```python
  await client.close()
  ```



  You can initialize the client with `read_timeout` and `write_timeout` to limit how long to wait for
  requests to complete. `read_timeout` applies to `get` and `query` whereas `write_timeout` applies to
  `update`:

  ```python
  import aiosolr

  client = aiosolr.Client(connection_url=connection_url, read_timeout=5, write_timeout=30)
  ```

  You can override the timeouts for a specific request:

  ```python
  await client.get(document_id, read_timeout=1)  # I'm in a hurry
  await client.update(doc, write_timeout=60)  # this is a large request so we expect it to take a long time
  ```

  > `aiosolr` uses
  > [`asyncio.wait_for`](https://docs.python.org/3/library/asyncio-task.html#asyncio.wait_for)
  > internally, so if a timeout occurs the exception raised is `asyncio.TimeoutError`.



  To get more information from the Client you can initialize with `debug=True`:

  ```python
      import aiosolr

      client = aiosolr.Client(host=localhost, collection="example", port=8983, debug=True)
  ```

  This sets the `aiosolr` logger to `DEBUG` level, and also sets the internally used HTTP session
  (provided by [aiohttp](https://docs.aiohttp.org/en/stable/logging.html)) to the `DEBUG` level. This
  makes it easier to see the actual network requests going to Solr.


pkgId: c020ef607a4ae49c698d2a06e0d1b76e1100bbafece62d909e5315256a22b613
name: python-aiosonic
arch: src
version: 0.22.0
epoch: 0
release: 1
summary: Async http client
url: https://aiosonic.readthedocs.io/en/latest/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosonic-0.22.0-1.src.rpm
checksum_type: sha256
description:
  ![github status](https://github.com/sonic182/aiosonic/actions/workflows/python.yml/badge.svg)
  [![Coverage Status](https://coveralls.io/repos/github/sonic182/aiosonic/badge.svg?branch=master)](https://coveralls.io/github/sonic182/aiosonic?branch=master)
  [![PyPI version](https://badge.fury.io/py/aiosonic.svg)](https://badge.fury.io/py/aiosonic)
  [![Documentation Status](https://readthedocs.org/projects/aiosonic/badge/?version=latest)](https://aiosonic.readthedocs.io/en/latest/?badge=latest)
  [![Discord](https://img.shields.io/discord/898929656969965648)](https://discord.gg/e7tBnYSRjj)




  Very fast, lightweight Python asyncio http client

  Here is some [documentation](https://aiosonic.readthedocs.io/en/latest/).

  There is a performance script in tests folder which shows very nice numbers

  ```
  » python tests/performance.py
  doing tests...
  {
   "aiosonic": "1000 requests in 105.53 ms",
   "aiosonic cyclic": "1000 requests in 104.08 ms",
   "aiohttp": "1000 requests in 184.51 ms",
   "requests": "1000 requests in 1644.21 ms"
  }
  aiosonic is 74.84% faster than aiohttp
  aiosonic is 1457.99% faster than requests
  aiosonic is -1.38% faster than aiosonic cyclic
  ```

  This is a *very basic, dummy test*, machine dependant. If you look for performance, test and compare your code with this and other packages like aiohttp.

  You can perform this test by installing all test dependencies with `pip install -e ".[test]"` and doing `python tests/performance.py` in your own machine



  * Python>=3.8
  * PyPy>=3.8




  * Keepalive and smart pool of connections
  * Multipart File Uploads
  * Chunked responses handling
  * Chunked requests
  * Connection Timeouts
  * Automatic Decompression
  * Follow Redirects
  * Fully type annotated.
  * 100% test coverage (Sometimes not).
  * HTTP2 (BETA) when using the correct flag



  `pip install aiosonic`



  ```python
  import asyncio
  import aiosonic
  import json


  async def run():
      client = aiosonic.HTTPClient()

      
      
      
      response = await client.get('https://www.google.com/')
      assert response.status_code == 200
      assert 'Google' in (await response.text())

      
      
      
      url = "https://postman-echo.com/post"
      posted_data = {'foo': 'bar'}
      response = await client.post(url, data=posted_data)

      assert response.status_code == 200
      data = json.loads(await response.content())
      assert data['form'] == posted_data

      
      
      
      response = await client.post(url, json=posted_data)

      assert response.status_code == 200
      data = json.loads(await response.content())
      assert data['json'] == posted_data

      
      
      
      from aiosonic.timeout import Timeouts
      timeouts = Timeouts(
          sock_read=10,
          sock_connect=3
      )
      response = await client.get('https://www.google.com/', timeouts=timeouts)
      assert response.status_code == 200
      assert 'Google' in (await response.text())

      print('success')


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



  * HTTP2
    * [x] Get
    * [x] Request with data sending
    * [ ] Do a aiosonic release with stable http2
  * Better documentation
  * International Domains and URLs (idna + cache)
  * Basic/Digest Authentication
  * [x] Requests using a http proxy
  * [x] Sessions with Cookie Persistence
  * [x] Elegant Key/Value Cookies



  Install packages with poetry

  Reference: https://python-poetry.org/docs/

  ```bash
  poetry install
  ```

  It is advised that you should install poetry in a serparate virtualenv (I suggest to install it with apt/pacman/etc.), other than the one you may use for development in aiosonic.

  I do configure poetry with `poetry config virtualenvs.in-project true` so it uses a virtualenv created in `.venv/`, in aiosonic folder.



  ```bash
  poetry run py.test
  ```



  1. Fork
  2. create a branch `feature/your_feature`
  3. commit - push - pull request

  Thanks :)



  <a href="https://github.com/sonic182/aiosonic/graphs/contributors">
   <img src="https://contributors-img.web.app/image?repo=sonic182/aiosonic" />
  </a>


pkgId: ec338f20b16616698478fcd1494f8b57eb4b4483946c3bc83182b10a818a0988
name: python-aiosql
arch: src
version: 13.0
epoch: 0
release: 1
summary: Simple SQL in Python
url: https://pypi.org/project/aiosql/
rpm_license: BSD 2-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosql-13.0-1.src.rpm
checksum_type: sha256
description:
  `SQL <https://en.wikipedia.org/wiki/SQL>`__ is code.
  Write it, version control it, comment it, and run it using files.
  Writing your SQL code in Python programs as strings doesn't allow you to easily
  reuse them in SQL GUIs or CLI tools like ``psql``.
  With aiosql you can organize your SQL statements in *.sql* files, load them
  into your python application as methods to call without losing the ability to
  use them as you would any other SQL file.
  This project supports standard
  `PEP 249 <https://peps.python.org/pep-0249/>`__
  and
  `asyncio <https://docs.python.org/3/library/asyncio.html>`__
  based drivers for
  `SQLite <https://www.sqlite.org/>`__
  (`sqlite3 <https://docs.python.org/3/library/sqlite3.html>`__,
  `aiosqlite <https://aiosqlite.omnilib.dev/en/latest/?badge=latest>`__,
  `apsw <https://pypi.org/project/apsw/>`__),
  `PostgreSQL <https://postgresql.org/>`__
  (`psycopg (3) <https://www.psycopg.org/psycopg3/>`__,
  `psycopg2 <https://www.psycopg.org/docs/>`__,
  `pg8000 <https://pypi.org/project/pg8000/>`__,
  `pygresql <http://www.pygresql.org/>`__,
  `asyncpg <https://magicstack.github.io/asyncpg/current/>`__),
  `MySQL <https://www.mysql.com/>`__
  (`PyMySQL <https://github.com/PyMySQL/PyMySQL/>`__,
  `mysqlclient <https://pypi.org/project/mysqlclient/>`__,
  `mysql-connector <https://dev.mysql.com/doc/connector-python/en/>`__,
  `asyncmy <https://github.com/long2ice/asyncmy>`__ with
  `this adapter <https://github.com/GoogleCloudPlatform/database-assessment/blob/main/src/dma/lib/db/adapters/asyncmy.py>`__),
  `MariaDB <https://mariadb.org/>`__
  (`mariadb <https://pypi.org/project/mariadb/>`__),
  `DuckDB <https://www.duckdb.org/>`__
  (`duckdb <https://duckdb.org/docs/api/python/dbapi>`__) and
  `MS SQL Server <https//en.wikipedia.org/wiki/Microsoft_SQL_Server>`__
  (`pymssql <https://pypi.org/project/pymssql/>`__),
  However, some detailed feature support may vary depending on the underlying driver
  and database engine actual capabilities.
  Other SQL database drivers which support the ``pyformat`` or ``named``
  `PEP 249 <https://peps.python.org/pep-0249/>`__ paramstyles should work as well
  by just passing the driver as a parameter when building queries.  Thus
  `Oracle Database <https://en.wikipedia.org/wiki/Oracle_Database>`__
  (`oracledb <https://oracle.github.io/python-oracledb/>`__) or
  `Snowflake <https://en.wikipedia.org/wiki/Snowflake_Inc.>`__
  (`snowflake.connector <https://docs.snowflake.com/en/developer-guide/python-connector/python-connector>`__)
  should work out of the box…
  Please report with an issue if it actually works for you!
  Otherwise, extensions to support other database drivers can be written by you!
  See: `Database Driver Adapters <./database-driver-adapters.html>`__.
  Feel free to pull request!
  This module is an implementation of
  `Kris Jenkins' yesql <https://github.com/krisajenkins/yesql>`__
  `Clojure <https://clojure.org/>`__ library to the
  `Python <https://www.python.org/>`__
  `ecosystem <https://pypi.org/>`__.


pkgId: 93ed848e6a1b304d0b18bb65ed43029d6a56ba619773bbab0167f2f89f0ac69b
name: python-aiosql-mysql
arch: src
version: 0.0.1a1
epoch: 0
release: 1
summary: A MySQL driver adaptor for aiosql
url: https://github.com/kajuberdut/aiosql-mysql
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosql-mysql-0.0.1a1-1.src.rpm
checksum_type: sha256
description:
  <!--
  *** Thanks for checking out the Best-README-Template. If you have a suggestion
  *** that would make this better, please fork the repo and create a pull request
  *** or simply open an issue with the tag "enhancement".
  *** Thanks again! Now go create something AMAZING! :D
  -->



  <!-- PROJECT SHIELDS -->
  <!--
  *** I'm using markdown "reference style" links for readability.
  *** Reference links are enclosed in brackets [ ] instead of parentheses ( ).
  *** See the bottom of this document for the declaration of the reference variables
  *** for contributors-url, forks-url, etc. This is an optional, concise syntax you may use.
  *** https://www.markdownguide.org/basic-syntax/#reference-style-links
  -->
  [![Contributors][contributors-shield]][contributors-url]
  [![Forks][forks-shield]][forks-url]
  [![Stargazers][stars-shield]][stars-url]
  [![Issues][issues-shield]][issues-url]
  [![MIT License][license-shield]][license-url]
  [![LinkedIn][linkedin-shield]][linkedin-url]



  <!-- PROJECT LOGO -->
  <br />
  <p align="center">
    <a href="https://github.com/kajuberdut/aiosql-mysql">
      <img src="https://raw.githubusercontent.com/kajuberdut/aiosql-mysql/main/images/logo.svg" alt="Logo" width="160" height="160">
    </a>

    <h2 align="center">aiosql-mysql</h2>

  </p>



  <!-- TABLE OF CONTENTS -->
  <details open="open">
    <summary><h2 style="display: inline-block">Table of Contents</h2></summary>
    <ol>
      <li>
        <a href="#about-the-project">About The Project</a>
      </li>
      <li>
        <a href="#getting-started">Getting Started</a>
      </li>
      <li><a href="#usage">Usage</a>
        <!-- <ul>
          <li><a href="#further-examples">Further Examples</a></li>
        </ul> -->
      </li>
      <!-- <li><a href="#roadmap">Roadmap</a></li> -->
      <li><a href="#contributing">Contributing</a></li>
      <li><a href="#license">License</a></li>
      <li><a href="#contact">Contact</a></li>
      <li><a href="#thanks">Thanks</a></li>
    </ol>
  </details>



  <!-- ABOUT THE PROJECT -->


  aiosql-mysql is a database adaptor intended to allow the use of [asyncmy](https://github.com/long2ice/asyncmy) with [aiosql](https://github.com/nackjicholson/aiosql).



  This project is in early developement. The PyMySQL adaptor works but is not fully tested. AsyncMy is not implimented and working at this time, please check back later.


  <!-- GETTING STARTED -->


  <!-- To get a local copy up and running follow these simple steps. -->
  <!-- ### Installing with pip -->
    <!-- ```sh
    pip install aiosql-mysql
    ``` -->

  For information about cloning and dev setup see: [Contributing](#Contributing)


  <!-- USAGE EXAMPLES -->

  This is example is adapted from aiosql's readme.

  *users.sql*

  ```sql

  -- name: get-user-by-username^
  SELECT *
  FROM users
  WHERE username = :username;

  -- name: create_users#
  CREATE TABLE users ( userid INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
                       username VARCHAR(100),
                       firstname VARCHAR(100),
                       lastname VARCHAR(100)
  );

  -- name: insert_bob!
  INSERT INTO users (username, firstname, lastname)
  VALUES ('bob', 'bob', 'smith');

  ```


  Indexing a document adds it to or updates it in the search store.
  ```python
  import aiosql
  import pymysql
  from aiosql_mysql import PyMySQLAdaptor

  conn = pymysql.connect(
          host="127.0.0.1",
          port=3306,
          user="root",
          password="password",
          database="ExampleDb",
          cursorclass=pymysql.cursors.DictCursor,
      )

  queries = aiosql.from_path("./users.sql", PyMySQLAdaptor)
  queries.create_users(conn)
  queries.insert_bob(conn)
  result = queries.get_user_by_username(conn, username="bob")
  print(result)


  ```

  For a more detailed and complete version of the above example see [pymysql_example.py](https://github.com/kajuberdut/aiosql-mysql/blob/main/examples/pymysql_example.py) & [users.sql](https://github.com/kajuberdut/aiosql-mysql/blob/main/examples/users.sql)


  ```python
  import aiosql
  import asyncmy
  from aiosql_mysql import AsyncMySQLAdapter

  queries = aiosql.from_path("./users.sql", AsyncMySQLAdapter)

  async def main():
      conn = await asyncmy.connect(
          host="127.0.0.1",
          port=3306,
          user="root",
          password="password",
          database="ExampleDb",
      )

      await queries.create_users(conn)
      await queries.insert_user(conn,user_name='sbob', first_name='Bob', last_name='Smith')
      result = await queries.get_user_by_username(conn, username="sbob")
      print(result)


  if __name__ == "__main__":
    import asyncio

    asyncio.run(main())
    
  ```
  For a more detailed and complete version of the above example see [asyncmy_example.py](https://github.com/kajuberdut/aiosql-mysql/blob/main/examples/asyncmy_example.py) & [users.sql](https://github.com/kajuberdut/aiosql-mysql/blob/main/examples/users.sql)

  <!-- CONTRIBUTING -->

  See the [open issues](https://github.com/kajuberdut/aiosql-mysql/issues) for a list of proposed features (and known issues).

  Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are **greatly appreciated**.

  1. Fork the Project
  2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
  <!-- 3. Add tests, we aim for 100% test coverage [Using Coverage](https://coverage.readthedocs.io/en/coverage-5.3.1/#using-coverage-py) -->
  4. execute: py.test --cov-report xml:cov.xml --cov
  5. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
  6. Push to the Branch (`git push origin feature/AmazingFeature`)
  7. Open a Pull Request


  1. Clone the repo and install
      ```sh
      git clone https://github.com/kajuberdut/aiosql-mysql.git
      cd aiosql-mysql
      pipenv install --dev
      ```
  2. Run tests
      ```sh
      pipenv shell
      ward
      ```
    For more about pipenv see: [Pipenv Github](https://github.com/pypa/pipenv)



  <!-- LICENSE -->


  Distributed under the MIT. See `LICENSE` for more information.



  <!-- CONTACT -->


  Patrick Shechet - patrick.shechet@gmail.com

  Project Link: [https://github.com/kajuberdut/aiosql-mysql](https://github.com/kajuberdut/aiosql-mysql)


  <!-- THANKS -->

  This library would be pointless without:
  - [Will Vaughn, creator of aiosql](https://github.com/nackjicholson)
  - [The other contributors to aiosql](https://github.com/nackjicholson/aiosql/graphs/contributors)
  - [The PyMySql Team](https://github.com/PyMySQL/PyMySQL)
  - [Long2Ice, creator of asyncmy](https://github.com/long2ice)
  - [The aiomysql team who's work makes asyncmy possible](https://github.com/aio-libs/aiomysql/graphs/contributors)
  - Many Many others in the Python and Open Source communities


  <!-- MARKDOWN LINKS & IMAGES -->
  <!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
  [contributors-shield]: https://img.shields.io/github/contributors/kajuberdut/aiosql-mysql.svg?style=for-the-badge
  [contributors-url]: https://github.com/kajuberdut/aiosql-mysql/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/kajuberdut/aiosql-mysql.svg?style=for-the-badge
  [forks-url]: https://github.com/kajuberdut/aiosql-mysql/network/members
  [stars-shield]: https://img.shields.io/github/stars/kajuberdut/aiosql-mysql.svg?style=for-the-badge
  [stars-url]: https://github.com/kajuberdut/aiosql-mysql/stargazers
  [issues-shield]: https://img.shields.io/github/issues/kajuberdut/aiosql-mysql.svg?style=for-the-badge
  [issues-url]: https://github.com/kajuberdut/aiosql-mysql/issues
  [license-shield]: https://img.shields.io/badge/License-MIT-orange.svg?style=for-the-badge
  [license-url]: https://github.com/kajuberdut/aiosql-mysql/blob/main/LICENSE
  [linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
  [linkedin-url]: https://www.linkedin.com/in/patrick-shechet


pkgId: 0daaea2f009344a25b1eed0fbcadda486512c40ea493f96d58b1b762bdc2ed21
name: python-aiosqlembic
arch: src
version: 0.3.12
epoch: 0
release: 1
summary: Migrations powered by aiosql
url: https://gitlab.com/euri10/aiosqlembic
rpm_license: Unlicense
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosqlembic-0.3.12-1.src.rpm
checksum_type: sha256
description:
  ![pipeline](https://gitlab.com/euri10/aiosqlembic/badges/master/pipeline.svg)
  ![coverage](https://gitlab.com/euri10/aiosqlembic/badges/master/coverage.svg)
  ![documentation](https://readthedocs.org/projects/aiosqlembic/badge/?version=latest)
  Aiosqlembic aims at running database migrations powered by the awesome [aiosql](https://github.com/nackjicholson/aiosql)
  It's inspired by goose for those coming from go
  It is in development and likely to break


pkgId: aa9bcfa9d41146d78b49f11ab775234f686537e8b2340c168e5fee19bd366ca2
name: python-aiosqlite-black
arch: src
version: 0.21.0
epoch: 0
release: 1
summary: asyncio bridge to the standard sqlite3 module
url: https://pypi.org/project/aiosqlite-black/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosqlite-black-0.21.0-1.src.rpm
checksum_type: sha256
description:
  aiosqlite provides a friendly, async interface to sqlite databases.
  It replicates the standard ``sqlite3`` module, but with async versions
  of all the standard connection and cursor methods, plus context managers for
  automatically closing connections and cursors:
      async with aiosqlite.connect(...) as db:
          await db.execute("INSERT INTO some_table ...")
          await db.commit()
          async with db.execute("SELECT * FROM some_table") as cursor:
              async for row in cursor:
  It can also be used in the traditional, procedural manner:
      db = await aiosqlite.connect(...)
      cursor = await db.execute('SELECT * FROM some_table')
      row = await cursor.fetchone()
      rows = await cursor.fetchall()
      await cursor.close()
      await db.close()
  aiosqlite also replicates most of the advanced features of ``sqlite3``:
      async with aiosqlite.connect(...) as db:
          db.row_factory = aiosqlite.Row
          async with db.execute('SELECT * FROM some_table') as cursor:
              async for row in cursor:
                  value = row['column']
          await db.execute('INSERT INTO foo some_table')
          assert db.total_changes > 0


pkgId: 0725b5e8b5624a0491539e69d6ac9399d1d0b7803f97a202d9363f9aa5d17867
name: python-aiosqlitedict
arch: src
version: 0.0.29
epoch: 0
release: 1
summary: Aiosqlitedict is a Python Wrapper for Aiosqlite.
url: https://github.com/sabrysm/aiosqlitedict
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosqlitedict-0.0.29-1.src.rpm
checksum_type: sha256
description:
  ![aiosqlitedictbanner](https://user-images.githubusercontent.com/51752028/160848765-35b1577d-0d94-44e3-bca4-d7ef133b5a97.png)

  ![PyPI](https://img.shields.io/pypi/v/aiosqlitedict?style=flat)
  [![Downloads](https://pepy.tech/badge/aiosqlitedict)](https://pepy.tech/project/aiosqlitedict)

  Python Wrapper For sqlite3 and aiosqlite


  * Easy conversion between sqlite table and Python dictionary and vice-versa.
  * Execute SQL queries.
  * Get values of a certain column in a Python list.
  * delete from your table.
  * convert your json file into a sql database table.
  * Order your list with parameters like ``order_by``, ``limit`` ..etc
  * Choose any number of columns to your dict, which makes it faster for your dict to load instead of selecting all.




  ```bash
  py -m pip install -U aiosqlitedict
  ```




  Aiosqlite is used to import a SQLite3 table as a Python dictionary.
  In this example we have a database file named ``ds_data.db`` this database has a table named ``ds_salaries``
  ![ds_data.db](https://i.ibb.co/rvsrPCX/pic1.png)
  Now to create an instance of this table in python we do the following
  ```python
  >>> from aiosqlitedict.database import Connect

  >>> ds_salaries = Connect("ds_data.db", "ds_salaries", "id")
  ```
  now we can get rows of this table.
  ```python
  >>> async def some_func():
      ...
      >>> user_0 = await ds_salaries.to_dict(0, "job_title", "salary") # to get `job_title` and `salary` of user with id 0
      >>> print(user_0)
      {'job_title': 'Data Scientist', 'salary': 70000}
      >>> user_0 = await ds_salaries.to_dict(0, "*")  # to get all columns of user with id 0
      >>> print(user_0)
      {'id': 0, 'work_year': 2020, 'experience_level': 'MI', 'employment_type': 'FT', 'job_title': 'Data Scientist', 'salary': 70000, 'salary_currency': 'EUR', 'salary_in_usd': 79833, 'employee_residence': 'DE', 'remote_ratio': 0, 'company_location': 'DE', 'company_size': 'L'}
  ```
  now lets do some operations on our data
  ```python
      >>> user_0 = await ds_salaries.to_dict(0, "job_title", "salary")
      >>> user_0["salary"] += 676  # increase user 0's salary
      >>> print(user_0["salary"])
      70676

      
      >>> salaries = await ds_salaries.select("salary", limit=5, ascending=False)
      >>> print(salaries)
      [70000, 260000, 85000, 20000, 150000]

      
      >>> best_jobs = await ds_salaries.select("job_title", order_by="salary", limit=5, ascending=False)
      >>> print(best_jobs)
      ['Data Scientist', 'Data Scientist', 'BI Data Analyst', 'ML Engineer', 'ML Engineer']

      
      >>> best_jobs_2 = await ds_salaries.execute("SELECT job_title FROM ds_salaries ORDER BY salary DESC LIMIT 5")
      >>> print(best_jobs_2)
      [('Data Scientist',), ('Data Scientist',), ('BI Data Analyst',), ('ML Engineer',), ('ML Engineer',)]

      
      >>> scientists = await ds_salaries.select("job_title", like="scientist", distinct=True)
      >>> print(scientists)
      ['Data Scientist', 'Machine Learning Scientist', 'Lead Data Scientist', 'Research Scientist', 'AI Scientist', 'Principal Data Scientist', 'Applied Data Scientist', 'Applied Machine Learning Scientist', 'Staff Data Scientist']

      
      >>> ML_Engineers = await ds_salaries.execute("SELECT salary FROM ds_salaries WHERE job_title = 'ML Engineer'")
      >>> print(ML_Engineers)
      [(14000,), (270000,), (7000000,), (8500000,), (256000,), (20000,)]

      
      >>> high_salaries = await ds_salaries.select("salary", between=(10000000, 40000000))  # between 30M and 40M salary
      >>> print(sorted(high_salaries, reverse=True))
      [30400000, 11000000, 11000000]

      
      >>> high_salaries2 = await ds_salaries.select("salary", order_by="salary", limit=3, ascending=False) # same task with different method
      >>> print(high_salaries2)
      [30400000, 11000000, 11000000]
      >>> high_salaries3 = await ds_salaries.select("id", order_by="salary", limit=3, ascending=False) # id of richest to poorest
      >>> print(high_salaries3)
      [177, 7, 102]
  ```
  | :warning: Warning: Connect.select method is vulnerable to SQL injection.|
  | --- |

  Lets say you want to delete a certain user
  ```python
  >>> await ds_salaries.delete(5)  # removing user with id 5 from the table.
  ```
  finally updating our SQLite table
  ```python
  >>> await ds_salaries.to_sql(0, user_0) # Saving user 0's data to the table
  ```


  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.


  Please notice that
  this package is built-on top of ``aiosqlite``
  [MIT](https://github.com/sabrysm/aiosqlitedict/blob/main/LICENSE)


pkgId: 501e8ca23b9126d3f34cfaaf65427ba6b29098004069e4d309691454dfd9f441
name: python-aiostalk
arch: src
version: 1.3
epoch: 0
release: 1
summary: A Python 3 asyncio client for the beanstalkd work queue
url: https://github.com/koodaamo/aiostalk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiostalk-1.3-1.src.rpm
checksum_type: sha256
description:
  aiostalk is a small and shameless Python client library for communicating
  with the `beanstalkd`_ work queue.
  It is based on (and requires) another library called `greenstalk`_ by Justin Mayhew.


pkgId: 9c96139f2a2465706b67efea5aa0f61af7d663279f7a75596238a495ca9cc695
name: python-aiostdlib
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: Only the standard library... but asynchronous!
url: https://github.com/syubogdanov/aiostdlib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiostdlib-0.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Version][shields/pypi/version]][pypi/homepage]
  [![PyPI Downloads][shields/pypi/downloads]][pypi/homepage]
  [![License][shields/pypi/license]][github/license]
  [![Python Version][shields/python/version]][pypi/homepage]



  * Provides asynchronous versions of the standard libraries;
  * The same API as the Python's standard, blocking API;
  * Blocking IO is performed in a separate thread.



  For more, see the [documentation][github/docs].



  The library is available as [`aiostdlib`][pypi/homepage] on PyPI:

  ```shell
  pip install aiostdlib
  ```



  The `aiostdlib` API is the same as the standard library, except that it is asynchronous.



  ```python
  import asyncio

  from aiostdlib import builtins


  async def main() -> None:
      async with builtins.open("./file.txt", mode="w") as file:
          await file.write("aiostdlib")


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



  ```python
  import asyncio

  from aiostdlib import builtins, json


  async def main() -> None:
      async with builtins.open("./file.json", mode="w") as file:
          await json.dump(["aiostdlib"], file)


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



  ```python
  import asyncio

  from aiostdlib import pathlib


  async def main() -> None:
      path = pathlib.Path("file.txt")

      if not await path.exists():
          await path.write_text("aiostdlib")


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



  ```python
  import asyncio

  from aiostdlib import shutil


  async def main() -> None:
      await shutil.rmtree("/tmp/aioshutil")


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



  ```python
  import asyncio

  from aiostdlib import tarfile


  async def main() -> None:
      if not await tarfile.is_tarfile("./aiostdlib.tar.gz"):
          detail = "The file is not a `tar` archive"
          raise RuntimeError(detail)


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



  ```python
  import asyncio

  from aiostdlib import tempfile


  async def main() -> None:
      tempdir, path = await asyncio.gather(
          tempfile.gettempdir(),
          tempfile.mkdtemp(),
      )

      if not path.startswith(tempdir):
          detail = "This is strange..."
          raise RuntimeError(detail)


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



  ```python
  import asyncio

  from aiostdlib import builtins, tomllib


  async def main() -> None:
      async with builtins.open("./file.toml", mode="rb") as file:
          data = await tomllib.load(file)

          if "aiostdlib" not in data:
              detail = "Where is 'aiostdlib'?"
              raise RuntimeError(detail)


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



  ```python
  import asyncio

  from aiostdlib import zipfile


  async def main() -> None:
      if not await zipfile.is_zipfile("./aiostdlib.zip"):
          detail = "The file is not a `zip` archive"
          raise RuntimeError(detail)


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



  MIT License, Copyright (c) 2024 Sergei Bogdanov. See [LICENSE][github/license] file.

  <!-- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- -->

  [github/docs]: https://github.com/syubogdanov/aiostdlib/tree/main/docs/
  [github/license]: https://github.com/syubogdanov/aiostdlib/tree/main/LICENSE

  [pypi/homepage]: https://pypi.org/project/aiostdlib/

  [shields/pypi/downloads]: https://img.shields.io/pypi/dm/aiostdlib.svg?color=green
  [shields/pypi/license]: https://img.shields.io/pypi/l/aiostdlib.svg?color=green
  [shields/pypi/version]: https://img.shields.io/pypi/v/aiostdlib.svg?color=green
  [shields/python/version]: https://img.shields.io/pypi/pyversions/aiostdlib.svg?color=green


pkgId: bc6f90c0b30c32ad741bbead936c36a08ae343cd4fdfb2a3bcc88707098d6761
name: python-aiosteam-api
arch: src
version: 1.1.7
epoch: 0
release: 1
summary: Async Python Client wrapper for Steam API
url: https://github.com/jgavrus/aiosteam-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosteam-api-1.1.7-1.src.rpm
checksum_type: sha256
description:
  `pip install aiosteam-api`



  [Steam API Web "STEAM_API_KEY"](https://steamcommunity.com/dev/api"STEAM_API_KEY")

  Follow instructions to get API "STEAM_API_KEY"





  ```python
  import asyncio
  from aiosteam_api import Steam

  steam = Steam("STEAM_API_KEY")


  async def some_async_foo():
    user = await steam.search_user("jeygavrus")  # also you can use steam user id for searching


  asyncio.run(some_async_foo())
  ```

  it will return User - a pydantic model with additional methods for getting more detail info.
  if you want reformat model to dict use ```user.model_dump()``` method.
  Or ```user.model_dump_json()``` for getting json string.

  JSON Response example:

  ```json
  {
    "steam_id": 76561198144619553,
    "player_lvl": null,
    "community_visibility_state": 3,
    "profile_state": 1,
    "persona_name": "stef1k",
    "profile_url": "https://steamcommunity.com/id/jeygavrus/",
    "avatar": {
      "avatar": "https://avatars.steamstatic.com/ba6060e3847fb5571a4c28f0994884d21fbfb1a2.jpg",
      "avatar_medium": "https://avatars.steamstatic.com/ba6060e3847fb5571a4c28f0994884d21fbfb1a2_medium.jpg",
      "avatar_full": "https://avatars.steamstatic.com/ba6060e3847fb5571a4c28f0994884d21fbfb1a2_full.jpg",
      "avatar_hash": "ba6060e3847fb5571a4c28f0994884d21fbfb1a2"
    },
    "last_logoff": 1724462578,
    "persona_state": 0,
    "real_name": "Євгеній",
    "primary_clan_id": 103582791429521408,
    "time_created": 1405203743,
    "persona_state_flags": 0,
    "loc_country_code": "UA",
    "friends": null,
    "last_played_games": null,
    "owned_games": null,
    "user_badges": null
  }
  ```



  By default, these fields are empty. For getting this info - you should use get_* method

  Example:

  ```python
  import asyncio
  from aiosteam_api import Steam

  steam = Steam("STEAM_API_KEY")


  async def some_async_foo():
    user = await steam.search_user("jeygavrus")  # also you can use steam user id for searching
    print(user.owned_games)  # None
    games = await user.get_owned_games()
    print(games)  # dict {int_id : Game}
    print(user.owned_games)  # dict {int_id : Game}


  asyncio.run(some_async_foo())
  ```

  Owned games dict example

  ```json
  {
    20920: {
      "app_id": 20920,
      "name": "The Witcher 2: Assassins of Kings Enhanced Edition",
      "playtime_two_weeks": 1015,
      // all time parameters in minutes
      "playtime_forever": 1994,
      "img_icon_url": "62dd5c627664df1bcabc47727c7dcd7ccab353e9"
    }
  }
  ```



  the same principe as with games

  ```python
  import asyncio

  from aiosteam_api import Steam

  steam = Steam("STEAM_API_KEY")


  async def some_async_foo():
    user = await steam.search_user("jeygavrus")  # also you can use steam user id for searching
    user_friends = await user.get_user_friends_list()
    print(user_friends)  # list[User]
    print(user.friends)


  asyncio.run(some_async_foo())
  ```

  Response

  ```json
   [
    {
      "steam_id": 123456789,
      "player_lvl": null,
      "community_visibility_state": 3,
      "profile_state": 1,
      "persona_name": "Зеновій Гучок",
      "profile_url": "https://steamcommunity.com/id/123456789/",
      "avatar": {
        "avatar": "https://avatars.steamstatic.com/xxxxx.jpg",
        "avatar_medium": "https://avatars.steamstatic.com/xxxxx_medium.jpg",
        "avatar_full": "https://avatars.steamstatic.com/xxxxx_full.jpg",
        "avatar_hash": "68839dbe297c62958aa507d2a0a87052b209540e"
      },
      "last_logoff": 1724503422,
      "persona_state": 0,
      "real_name": "Denys",
      "primary_clan_id": 123456,
      "time_created": 1423770633,
      "persona_state_flags": 0,
      "loc_country_code": "UA",
      "friends": null,
      "last_played_games": null,
      "owned_games": null,
      "user_badges": null,
      "relationship": "friend",
      "friend_since": 1691321801
    }
  ]

  ```





  ```python
  import asyncio

  from aiosteam_api import Steam

  steam = Steam("STEAM_API_KEY")


  user = asyncio.run(steam.apps.search_games("terr"))
  ```

  Response

  ```json
  {
    "apps": [
      {
        "id": 105600,
        "link": "https://store.steampowered.com/app/105600/Terraria/?snr=1_7_15__13",
        "name": "Terraria",
        "img": "https://cdn.akamai.steamstatic.com/steam/apps/105600/capsule_sm_120.jpg?t=1590092560",
        "price": "$9.99"
      },
      {
        "id": 1202130,
        "link": "https://store.steampowered.com/app/1202130/Starship_Troopers_Terran_Command/?snr=1_7_15__13",
        "name": "Starship Troopers: Terran Command",
        "img": "https://cdn.akamai.steamstatic.com/steam/apps/1202130/capsule_sm_120.jpg?t=1657104501",
        "price": "$29.99"
      },
      {
        "id": 1176470,
        "link": "https://store.steampowered.com/app/1176470/Terra_Invicta/?snr=1_7_15__13",
        "name": "Terra Invicta",
        "img": "https://cdn.akamai.steamstatic.com/steam/apps/1176470/capsule_sm_120.jpg?t=1659933796",
        "price": ""
      },
      {
        "id": 1945600,
        "link": "https://store.steampowered.com/app/1945600/The_Riftbreaker_Metal_Terror/?snr=1_7_15__13",
        "name": "The Riftbreaker: Metal Terror",
        "img": "https://cdn.akamai.steamstatic.com/steam/apps/1945600/capsule_sm_120.jpg?t=1659109312",
        "price": "$9.99"
      },
      {
        "id": 285920,
        "link": "https://store.steampowered.com/app/285920/TerraTech/?snr=1_7_15__13",
        "name": "TerraTech",
        "img": "https://cdn.akamai.steamstatic.com/steam/apps/285920/capsule_sm_120.jpg?t=1644900341",
        "price": "$24.99"
      }
    ]
  }
  ```





  - `app_id` (int): The unique App ID of the app you want to retrieve details for. For example, 105600 corresponds to "
    Terraria"

  - `country` (str): An optional parameter representing the ISO Country Code. The default value is "US."

  - `filters` (str): An optional parameter that allows you to specify a list of "STEAM_API_KEY"s to return in the app
    details. If not provided, it defaults to "basic." The available filter options include:

  - `basic` (Default): Returns essential information like type, name, steam_appid, required_age, is_free, dlc,
    detailed_description, short_description, about_the_game, supported_languages, header_image, website, pc_requirements,
    mac_requirements, and linux_requirements.

  - Optional filters (Specify one or more of these as a comma-separated string):
      - controller_support
      - dlc
      - fullgame
      - legal_notice
      - developers
      - demos
      - price_overview
      - metacritic
      - categories
      - genres
      - screenshots
      - movies
      - recommendations
      - achievements
        Response

  ```python
  import asyncio

  from aiosteam_api import Steam

  terraria_app_id = 105600
  steam = Steam("STEAM_API_KEY")


  user = asyncio.run(steam.apps.get_app_details(terraria_app_id))

  ```

  ```json
  {
    "105600": {
      "success": true,
      "data": {
        "type": "game",
        "name": "Terraria",
        "steam_appid": 105600,
        "required_age": 0,
        "is_free": false,
        "controller_support": "full",
        "dlc": [
          409210,
          1323320
        ],
        "detailed_description": "Dig, Fight, Explore, Build:  The very world is at your fingertips as you fight for survival, fortune, and glory.   Will you delve deep into cavernous expanses in search of treasure and raw materials with which to craft ever-evolving gear, machinery, and aesthetics?   Perhaps you will choose instead to seek out ever-greater foes to test your mettle in combat?   Maybe you will decide to construct your own city to house the host of mysterious allies you may encounter along your travels? <br><br>In the World of Terraria, the choice is yours!<br><br>Blending elements of classic action games with the freedom of sandbox-style creativity, Terraria is a unique gaming experience where both the journey and the destination are completely in the player’s control.   The Terraria adventure is truly as unique as the players themselves!  <br><br>Are you up for the monumental task of exploring, creating, and defending a world of your own?  <br><br>\t\t\t\t\t\t\t<strong> features:</strong><br>\t\t\t\t\t\t\t<ul class=\"bb_ul\"><li>Sandbox Play<br>\t\t\t\t\t\t\t</li><li> Randomly generated worlds<br>\t\t\t\t\t\t\t</li><li>Free Content Updates<br>\t\t\t\t\t\t\t</li></ul>",
        "about_the_game": "Dig, Fight, Explore, Build:  The very world is at your fingertips as you fight for survival, fortune, and glory.   Will you delve deep into cavernous expanses in search of treasure and raw materials with which to craft ever-evolving gear, machinery, and aesthetics?   Perhaps you will choose instead to seek out ever-greater foes to test your mettle in combat?   Maybe you will decide to construct your own city to house the host of mysterious allies you may encounter along your travels? <br><br>In the World of Terraria, the choice is yours!<br><br>Blending elements of classic action games with the freedom of sandbox-style creativity, Terraria is a unique gaming experience where both the journey and the destination are completely in the player’s control.   The Terraria adventure is truly as unique as the players themselves!  <br><br>Are you up for the monumental task of exploring, creating, and defending a world of your own?  <br><br>\t\t\t\t\t\t\t<strong> features:</strong><br>\t\t\t\t\t\t\t<ul class=\"bb_ul\"><li>Sandbox Play<br>\t\t\t\t\t\t\t</li><li> Randomly generated worlds<br>\t\t\t\t\t\t\t</li><li>Free Content Updates<br>\t\t\t\t\t\t\t</li></ul>",
        "short_description": "Dig, fight, explore, build! Nothing is impossible in this action-packed adventure game. Four Pack also available!",
        "supported_languages": "English, French, Italian, German, Spanish - Spain, Polish, Portuguese - Brazil, Russian, Simplified Chinese",
        "header_image": "https://cdn.akamai.steamstatic.com/steam/apps/105600/header.jpg?t=1666290860",
        "capsule_image": "https://cdn.akamai.steamstatic.com/steam/apps/105600/capsule_231x87.jpg?t=1666290860",
        "capsule_imagev5": "https://cdn.akamai.steamstatic.com/steam/apps/105600/capsule_184x69.jpg?t=1666290860",
        "website": "http://www.terraria.org/",
        "pc_requirements": {
          "minimum": "<h2 class=\"bb_tag\"><strong>REQUIRED</strong></h2><ul class=\"bb_ul\"><li><strong>OS: Windows Xp, Vista, 7, 8/8.1, 10</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Processor: 2.0 Ghz</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Memory: 2.5GB</strong><br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Hard Disk Space: 200MB </strong> \t<br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Video Card: 128mb Video Memory, capable of Shader Model 2.0+</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>DirectX®: 9.0c or Greater</strong> \t<br>\t\t\t\t\t\t\t\t\t</li></ul>",
          "recommended": "<h2 class=\"bb_tag\"><strong>RECOMMENDED</strong></h2><ul class=\"bb_ul\"><li><strong>OS: Windows 7, 8/8.1, 10</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Processor: Dual Core 3.0 Ghz</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Memory: 4GB</strong><br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Hard Disk Space: 200MB </strong> \t<br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Video Card: 256mb Video Memory, capable of Shader Model 2.0+</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>DirectX®: 9.0c or Greater</strong> \t<br>\t\t\t\t\t\t\t\t\t</li></ul>"
        },
        "mac_requirements": {
          "minimum": "<h2 class=\"bb_tag\"><strong>REQUIRED</strong></h2><ul class=\"bb_ul\"><li><strong>OS: OSX 10.9.5 - 10.11.6</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Processor: 2.0 Ghz</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Memory: 2.5GB</strong><br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Hard Disk Space: 200MB </strong> \t<br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Video Card: 128mb Video Memory, capable of OpenGL 3.0+ support (2.1 with ARB extensions acceptable</strong> <br>\t\t\t\t\t\t\t\t\t</li></ul>",
          "recommended": "<h2 class=\"bb_tag\"><strong>RECOMMENDED</strong></h2><ul class=\"bb_ul\"><li><strong>OS: OSX 10.9.5 - 10.11.6</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Processor: Dual Core 3.0 Ghz</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Memory: 4GB</strong><br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Hard Disk Space: 200MB </strong> \t<br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Video Card: 256mb Video Memory, capable of OpenGL 3.0+ support (2.1 with ARB extensions acceptable</strong> <br>\t\t\t\t\t\t\t\t\t</li></ul>"
        },
        "linux_requirements": {
          "minimum": "<h2 class=\"bb_tag\"><strong>REQUIRED</strong></h2>LINUX<br><ul class=\"bb_ul\"><li><strong>OS: Ubuntu 14.04 LTS</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Processor: 2.0 Ghz</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Memory: 2.5GB</strong><br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Hard Disk Space: 200MB </strong> \t<br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Video Card: 128mb Video Memory, capable of OpenGL 3.0+ support (2.1 with ARB extensions acceptable</strong> <br>\t\t\t\t\t\t\t\t\t</li></ul>",
          "recommended": "<h2 class=\"bb_tag\"><strong>RECOMMENDED</strong></h2>LINUX<br><ul class=\"bb_ul\"><li><strong>OS: Ubuntu 14.04 LTS</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Processor: Dual Core 3.0 Ghz</strong> <br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Memory: 4GB</strong><br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Hard Disk Space: 200MB </strong> \t<br>\t\t\t\t\t\t\t\t\t\t</li><li><strong>Video Card: 256mb Video Memory, capable of OpenGL 3.0+ support (2.1 with ARB extensions acceptable</strong> <br>\t\t\t\t\t\t\t\t\t</li></ul>"
        }
      }
    }
  }
  ```



  ```python
  import asyncio

  from aiosteam_api import Steam

  steam = Steam("STEAM_API_KEY")


  user = asyncio.run(steam.apps.get_user_stats("<steam_id>", "<app_id>"))
  ```



  ```python
  import asyncio

  from aiosteam_api import Steam

  steam = Steam("STEAM_API_KEY")


  user = asyncio.run(steam.apps.get_user_achievements("<steam_id>", "<app_id>"))
  ```



  ```python
  import asyncio

  from aiosteam_api import Steam

  steam = Steam("STEAM_API_KEY")


  user = asyncio.run(steam.users.get_player_bans("<steam_id>"))
  ````

  ```json
  {
    "players": [
      {
        "SteamId": "76561198144619553",
        "CommunityBanned": false,
        "VACBanned": false,
        "NumberOfVACBans": 0,
        "DaysSinceLastBan": 0,
        "NumberOfGameBans": 0,
        "EconomyBan": "none"
      }
    ]
  }
  ```


pkgId: 1afee7284f9c57610c42d1398c6830a01f563d938f996874b3b221d8cc1f7556
name: python-aiosteamist
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Control Steamist steam systems
url: https://github.com/bdraco/aiosteamist
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosteamist-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/bdraco/aiosteamist/actions?query=workflow%3ACI">
      <img src="https://img.shields.io/github/workflow/status/bdraco/aiosteamist/CI/main?label=CI&logo=github&style=flat-square" alt="CI Status" >
    </a>
    <a href="https://aiosteamist.readthedocs.io">
      <img src="https://img.shields.io/readthedocs/aiosteamist.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
    </a>
    <a href="https://codecov.io/gh/bdraco/aiosteamist">
      <img src="https://img.shields.io/codecov/c/github/bdraco/aiosteamist.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
    </a>
  </p>
  <p align="center">
    <a href="https://python-poetry.org/">
      <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
    </a>
    <a href="https://github.com/ambv/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square" alt="black">
    </a>
    <a href="https://github.com/pre-commit/pre-commit">
      <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
    </a>
  </p>
  <p align="center">
    <a href="https://pypi.org/project/aiosteamist/">
      <img src="https://img.shields.io/pypi/v/aiosteamist.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/aiosteamist.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
    <img src="https://img.shields.io/pypi/l/aiosteamist.svg?style=flat-square" alt="License">
  </p>

  Control Steamist steam systems



  Install this via pip (or your favourite package manager):

  `pip install aiosteamist`



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <!-- markdownlint-enable -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!



  This package was created with
  [Cookiecutter](https://github.com/audreyr/cookiecutter) and the
  [browniebroke/cookiecutter-pypackage](https://github.com/browniebroke/cookiecutter-pypackage)
  project template.


pkgId: 9148b8fac6de4317dc4decf108a3432ff13968391fcb09966faad2e5e1493ce1
name: python-aiosteampy
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Trade and interact with steam market, webapi, guard
url: https://aiosteampy.somespecial.one
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosteampy-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner-direct-single.svg)](https://stand-with-ukraine.pp.ua)
  <!--header-end-->
  > [!IMPORTANT]
  > The project is unstable and there might be some breaking changes in the future unless stable (**first major**) version
  > is released.
  >
  > Take a look at [TODO](#todo-)
  >
  > See full documentation [here](https://aiosteampy.somespecial.one/) 📖
  <!--install-start-->

  ```shell
  pip install aiosteampy
  ```
  ```shell
  pipenv install aiosteampy
  ```
  ```shell
  poetry add aiosteampy
  ```
  Project have some extras [currencies converter](https://aiosteampy.somespecial.one/ext/converter/),
  [socks proxies](https://aiosteampy.somespecial.one/proxies).
  To install them all, please, use `aiosteampy[all]` install target:
  ```shell
  poetry add aiosteampy[all]
  ```
  <!--install-end-->
  > [!TIP]
  > [aiohttp docs](https://docs.aiohttp.org/en/stable/#installing-all-speedups-in-one-command) recommends installing
  > speedups (`aiodns`, `cchardet`, ...)
  <!--intro-start-->
  AIOSTEAMPY use [aiohttp](https://github.com/aio-libs/aiohttp) underneath to do asynchronous requests to steam servers,
  with modern async/await syntax.

  - **Stateless**: low-middle layer API wrapper of some steam services and methods like market,
    tradeoffers, confirmations, steamguard, etc.
  - **Declarative**: there is models or `TypedDict`s for every data.
  - **Typed**: High-end support with extensive typing, tested on `VSCode` and `PyCharm`.
  - **Simple**: Fit most important related to steam trading process methods.
  - **Web proxy** support.

  - Operate with steam trade offers.
  - Sell, buy items on market. Place, cancel orders.
  - Login trough steam to 3rd party sites.
  - Fetch data from market.
  - Manipulate many accounts with proxies for each session.
  - Get and load cookies to stay logged in (session persistence).
  - Convert market prices into different currencies.

  - Chat.
  - Get apps, packages.
  - All, that need connection to CM.
  - Interact with game servers (inspect CS2 (ex. CSGO) items, ...).
  - Social interaction(groups, clans).
  - Handle entities (listings, items, tradeoffers) lifecycle for easy if you need to store it.
  <!--intro-end-->

  > [!WARNING]
  > Test cases and test code as a whole are deprecated and will not work until they are updated (a lot of work).
  > I'll leave the code and this heading here as a reminder 🫣
  [//]: # (Read [test documentation]&#40;https://aiosteampy.somespecial.one/tests/&#41; 📖)
  <!--footer-start-->

  > Hard to say **roadmap**. Can be a little changed or updated later, get ready.
  Path to first **stable release**. Non-exhaustive list, scheduled tasks can be done earlier than the version mentioned,
  but not otherwise.

  - [x] Listings, items, offers pagination/iteration
  - [x] Get single item from inventory as browser does
  - [x] Change client username method

  - [x] Remove storage methods. Caching entities must be user responsibility
  - [x] Rename `fetch_...` methods to `get_...` to remove annoying methods symantic mess
  - [x] ~~Web browser mechanism to fetch trade offers from `Steam`, avoiding `Steam Web Api`~~
  - [x] Edit profile privacy settings

  - [ ] Context managers as helpers to login/logout, load/dump or get/put cookies
  - [x] Fetch/paginate over market search pages

  - [ ] `Steam user` model with minimal attrs, retrieving/fetching
  - [x] Refresh `access_token` mechanism

  - [ ] Tests with `Steam API` mocking. Target coverage ~70%. Key points (listings, inventory items, trade offers) testing
  suits is mandatory
  - [ ] Maturity, battle-testing in **more** different cases by **more** participants/users

  There is no rules or requirements to contribute. Feedbacks, suggests, other are welcome.
  I will be very grateful for helping me get the things right.

  - [bukson/steampy](https://github.com/bukson/steampy)
  - [aiohttp-socks](https://github.com/romis2012/aiohttp-socks)
  - [croniter](https://github.com/kiorky/croniter)
  - [DoctorMcKay/node-steamcommunity](https://github.com/DoctorMcKay/node-steamcommunity)
  - [Identifying Steam items](https://dev.doctormckay.com/topic/332-identifying-steam-items/)
  - [Revadike/InternalSteamWebAPI](https://github.com/Revadike/InternalSteamWebAPI)
  - [Gobot1234/steam.py](https://github.com/Gobot1234/steam.py)
  - [Steam Market id's storage repo](https://github.com/somespecialone/steam-item-name-ids)
  - [steamapi.xpaw.me](https://steamapi.xpaw.me/)
  - [Steam Exchange Rate Tracker](https://github.com/somespecialone/sert)
  - [ethanfurman/aenum](https://github.com/ethanfurman/aenum)
  <!--footer-end-->


pkgId: 295c34c00288f34bd22a8adb933d0174fa9779c4e30b2d07f9558004ddaf0112
name: python-aiostomp
arch: src
version: 1.7.3
epoch: 0
release: 1
summary: Stompt Client for Asyncio applications
url: https://pypi.org/project/aiostomp/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiostomp-1.7.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/pedrokiefer/aiostomp.png?branch=master)](https://travis-ci.com/pedrokiefer/aiostomp)
  [![Coverage Status](https://coveralls.io/repos/github/pedrokiefer/aiostomp/badge.svg?branch=master)](https://coveralls.io/github/pedrokiefer/aiostomp?branch=master)
  [![PyPI version](https://badge.fury.io/py/aiostomp.svg)](https://badge.fury.io/py/aiostomp)



  Simple asyncio stomp 1.1 client for python 3.6.

  Heavely inspired on [torstomp](https://github.com/wpjunior/torstomp).



  with pip:

  ```bash
  pip install aiostomp
  ```



  ```python
  import sys
  import logging
  import asyncio

  from aiostomp import AioStomp

  logging.basicConfig(
      format="s - s:d - "
      "s - s",
      level='DEBUG')


  async def run():
      client = AioStomp('localhost', 61613, error_handler=report_error)
      client.subscribe('/queue/channel', handler=on_message)

      await client.connect()

      client.send('/queue/channel', body=u'Thanks', headers={})


  async def on_message(frame, message):
      print('on_message:', message)
      return True


  async def report_error(error):
      print('report_error:', error)


  def main(args):
      loop = asyncio.get_event_loop()
      loop.run_until_complete(run())
      loop.run_forever()


  if __name__ == '__main__':
      main(sys.argv)

  ```



  With empty virtualenv for this project, run this command:

  ```bash
  make setup
  ```

  and run all tests =)

  ```bash
  make test
  ```



  Fork, patch, test, and send a pull request.


pkgId: a36f63b3f332cb8840411ea398bbf69a16dfe4a83512a63c60e690e73551d5f5
name: python-aiostp
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: asyncio client library for stpmex.com
url: https://github.com/cuenca-mx/aiostp
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiostp-0.0.12-1.src.rpm
checksum_type: sha256
description:
  asyncio client library for stpmex.com


  [![test](https://github.com/cuenca-mx/aiostp/workflows/test/badge.svg)](https://github.com/cuenca-mx/aiostp/actions?query=workflow%3Atest)
  [![codecov](https://codecov.io/gh/cuenca-mx/aiostp/branch/main/graph/badge.svg)](https://codecov.io/gh/cuenca-mx/aiostp)
  ![release](https://github.com/cuenca-mx/aiostp/workflows/release/badge.svg)




  `pip install aiostp`



  The preferred way to configure the credentials for the client is to set the
  `STP_PRIVATE_LOCATION` and `STP_KEY_PASSPHRASE` environment variables. The client
  library will automatically configure based on the values of those variables.
  `STP_PRIVATE_LOCATION` can be the route to the file, or the private key itself.

  To configure manually:
  ```python
  import aiostp

  aiostp.configure(priv_key='PKxxxx', priv_key_passphrase='yyyyyy')
  ```


pkgId: e36542f76672fd65bd123658d1da6c60e30c5fdf0bdc6d3b49a9e45ec8570383
name: python-aiostream
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Generator-based operators for asynchronous iteration
url: https://github.com/vxgmichel/aiostream
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiostream-0.6.2-1.src.rpm
checksum_type: sha256
description:
  |docs-badge| |cov-badge| |ci-badge| |version-badge| |pyversion-badge|
  Generator-based operators for asynchronous iteration

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  {one line to give the program's name and a brief idea of what it does.} Copyright (C) {year}  {name of author}  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  {project}  Copyright (C) {year}  {fullname} This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, your program's commands might be different; for a GUI interface, you would use an "about box".  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <http://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.  But first, please read <http://www.gnu.org/philosophy/why-not-lgpl.html>.


pkgId: d45dfad04c1adde5ca3f483f9d843f1bc3ebedd488f896845e4aaa0254f0533b
name: python-aiostreammagic
arch: src
version: 2.10.0
epoch: 0
release: 1
summary: An async python package for interfacing with Cambridge Audio / Stream Magic compatible streamers.
url: https://github.com/noahhusby/aiostreammagic
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiostreammagic-2.10.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">





  [**📖 Read the docs »**][docs]

  [![GitHub Release][releases-shield]][releases]
  [![Python Versions][python-versions-shield]][pypi]
  [![Downloads][downloads-shield]][pypi]
  ![Project Maintenance][maintenance-shield]
  [![License][license-shield]](LICENSE.md)

  </div>


  This module implements a Python client for the Stream Magic API used to control Cambridge Audio streamers. The API connects over websockets and supports several streamers, receivers, and pre-amps.


  - Cambridge Audio Evo 75
  - Cambridge Audio Evo 150
  - Cambridge Audio CXN
  - Cambridge Audio CXN (v2)
  - Cambridge Audio CXR120
  - Cambridge Audio CXR200
  - Cambridge Audio 851N
  - Cambridge Audio Edge NQ

  If your model is not on the list of supported devices, and everything works correctly then add it to the list by opening a pull request.


  ```shell
  pip install aiostreammagic
  ```




  ```python
  import asyncio

  from aiostreammagic import StreamMagicClient, Source, Info

  HOST = "192.168.20.218"


  async def main():
      """Basic demo entrypoint."""
      client = StreamMagicClient("192.168.20.218")
      await client.connect()

      info: Info = await client.get_info()
      sources: list[Source] = await client.get_sources()

      print(f"Model: {info.model}")
      for source in sources:
          print(f"Name: {source.id} ({source.id})")

      await client.disconnect()

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



  The Cambridge Audio StreamMagic API can automatically notify the client of changes instead of the need for polling. Register a callback to be called whenver new information is available.

  ```python
  import asyncio

  from aiostreammagic import StreamMagicClient

  HOST = "192.168.20.218"


  async def on_state_change(client: StreamMagicClient):
      """Called when new information is received."""
      print(f"System info: {client.get_info()}")
      print(f"Sources: {client.get_sources()}")
      print(f"State: {client.get_state()}")
      print(f"Play State: {client.get_play_state()}")
      print(f"Now Playing: {client.get_now_playing()}")

  async def main():
      """Subscribe demo entrypoint."""
      client = StreamMagicClient("192.168.20.218")
      await client.register_state_update_callbacks(on_state_change)
      await client.connect()

      
      await asyncio.sleep(60)

      await client.disconnect()


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

  [license-shield]: https://img.shields.io/github/license/noahhusby/aiostreammagic.svg
  [docs]: https://noahhusby.github.io/aiostreammagic/
  [downloads-shield]: https://img.shields.io/pypi/dm/aiostreammagic
  [python-versions-shield]: https://img.shields.io/pypi/pyversions/aiostreammagic
  [maintenance-shield]: https://img.shields.io/maintenance/yes/2024.svg
  [releases-shield]: https://img.shields.io/github/release/noahhusby/aiostreammagic.svg
  [releases]: https://github.com/noahhusby/aiostreammagic/releases
  [pypi]: https://pypi.org/project/aiostreammagic/


pkgId: 7b552b6fad31fe94023ec9664e8f03d1b5300062e39a69bb314a9ea22118defa
name: python-aiosu
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: Simple and fast osu! API v1 and v2 library
url: https://github.com/NiceAesth/aiosu
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosu-2.3.1-1.src.rpm
checksum_type: sha256
description:
  |Python| |pypi| |pre-commit.ci status| |rtd| |pytest| |mypy| |codacy|
  Simple and fast asynchronous osu! API v1 and v2 library with various utilities.


pkgId: 7d630efa0a92265c0fc295f19cfc4c53bef48d7b638f26496867d0a60e9d8184
name: python-aiosubpub
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Aio sub pub package.
url: https://github.com/sander76/pypubsub
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosubpub-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  ![CI](https://github.com/sander76/mspyteams/workflows/CI/badge.svg)
  [![codecov](https://codecov.io/gh/sander76/pypubsub/branch/master/graph/badge.svg)](https://codecov.io/gh/sander76/pypubsub)




  Async pub sub implementation.

  Inspired by someone else whose name I cannot find anymore. If you see your code (I did some improvements on it I think) please let me know and I am happy to give you credit.



  `pip install aiosubpub`



  ```python
  import aiosubpub
  import asyncio
  loop=asyncio.get_event_loop()


  a_channel = aiosubpub.Channel()


  def call_back(data):
      print(data)

  subscription = loop.create_task(a_channel.subscribe(call_back))


  a_channel.publish("a message")

  subscription.un_subscribe()




  subscription = a_channel.get_subscription()

  async def _custom_subscriber():
      with subscription as sub:
          result = await sub.get()
          print(result)

  a_channel.publish("a message")

  result = await _custom_subscriber()
  ```




  - Add `get_latest` to the channel.


pkgId: e3e1bc78fb3164ea905397d856dbb2720fa8fb24d75932ad05af017875e69e85
name: python-aiosubstrate
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A library for interacting with Substrate node (py-substrate-interface fork)
url: https://github.com/dipdup-io/aiosubstrate
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosubstrate-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Twitter](https://badgen.net/badge/icon/dipdup_io?icon=twitter&label=)](https://twitter.com/dipdup_io)
  [![Monthly downloads](https://static.pepy.tech/badge/aiosubstrate/month)](https://pepy.tech/project/dipdup)
  [![GitHub stars](https://img.shields.io/github/stars/dipdup-io/aiosubstrate?color=2c2c2c&style=plain)](https://github.com/dipdup-io/aiosubstrate)
  [![Python Version](https://img.shields.io/pypi/pyversions/dipdup?color=2c2c2c)](https://www.python.org)
  [![License: Apache](https://img.shields.io/github/license/dipdup-io/aiosubstrate?color=2c2c2c)](https://github.com/dipdup-io/aiosubstrate/blob/next/LICENSE)
  <br>
  [![Latest stable release](https://img.shields.io/github/v/release/dipdup-io/aiosubstrate?label=stable%20release&color=2c2c2c)](https://github.com/dipdup-io/aiosubstrate/releases)
  [![Latest pre-release](https://img.shields.io/github/v/release/dipdup-io/aiosubstrate?include_prereleases&label=latest%20release&color=2c2c2c)](https://github.com/dipdup-io/aiosubstrate/releases)
  [![GitHub issues](https://img.shields.io/github/issues/dipdup-io/aiosubstrate?color=2c2c2c)](https://github.com/dipdup-io/aiosubstrate/issues)
  [![GitHub pull requests](https://img.shields.io/github/issues-pr/dipdup-io/aiosubstrate?color=2c2c2c)](https://github.com/dipdup-io/aiosubstrate/pulls)

  > ⚠️ This project is not related to the PolkaScan team! Please, do not send them aiosubstrate bug reports!

  > ⚠️ This project is currently in the beta stage. Use with caution.

  A library for interacting with Substrate node, an unofficial fork of [py-substrate-interface](https://github.com/polkascan/py-substrate-interface) with primary goal to achieve compatibility with Python asyncio.



  This library specializes in interfacing with a [Substrate](https://substrate.io/) node; querying storage, composing extrinsics, SCALE encoding/decoding and providing additional convenience methods to deal with the features and metadata of the Substrate runtime.



  TBD.

  - [Upstream library documentation](https://polkascan.github.io/py-substrate-interface/)
  - [Upstream metadata documentation for Polkadot and Kusama ecosystem runtimes](https://polkascan.github.io/py-substrate-metadata-docs/)



  ```shell
  pip install aiosubstrate


  pip install aiosubstrate[full]
  ```



  ```python
  substrate = SubstrateInterface(url="ws://127.0.0.1:9944")
  ```

  After connecting certain properties like `ss58_format` will be determined automatically by querying the RPC node. At the moment this will work for most `MetadataV14` and above runtimes like Polkadot, Kusama, Acala, Moonbeam. For older or runtimes under development the `ss58_format` (default 42) and other properties should be set manually.





  ```python
  result = await substrate.query('System', 'Account', ['F4xQKRUagnSGjFqafyhajLs94e7Vvzvr8ebwYJceKpr8R7T'])
  print(result.value['data']['free']) # 635278638077956496
  ```



  ```python
  call = await substrate.compose_call(
      call_module='Balances',
      call_function='transfer',
      call_params={
          'dest': '5E9oDs9PjpsBbxXxRE9uMaZZhnBAV38n2ouLB28oecBDdeQo',
          'value': 1 * 10**12
      }
  )

  keypair = Keypair.create_from_uri('//Alice')
  extrinsic = await substrate.create_signed_extrinsic(call=call, keypair=keypair)

  receipt = await substrate.submit_extrinsic(extrinsic, wait_for_inclusion=True)

  print(f"Extrinsic '{receipt.extrinsic_hash}' sent and included in block '{receipt.block_hash}'")
  ```



  > ⚠️ This project is not related to the PolkaScan team! Please, do not send them aiosubstrate bug reports!

  For questions, please see the [Substrate StackExchange](https://substrate.stackexchange.com/questions/tagged/python), [upstream GitHub Discussions](https://github.com/polkascan/py-substrate-interface/discussions).



  [Apache 2.0](https://github.com/dipdup-io/aiosubstrate/blob/master/LICENSE)


pkgId: d10b4e709c93903261a207e7dbe3794af990cde9d81daed9d7a7be9c8c19bcce
name: python-aioswitcher
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: Switcher Python Integration.
url: https://pypi.org/project/aioswitcher/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioswitcher-4.1.0-1.src.rpm
checksum_type: sha256
description:
  [![gh-build-status]][7] [![gh-pages-status]][8] [![codecov]][3]

  PyPi module integrating with various [Switcher][12] devices.</br>
  Check out the [wiki pages][0] for a list of supported devices.

  ```shell
  pip install aioswitcher
  ```

  <table>
    <td><a href="https://aioswitcher.tomfi.info/">Documentation</a></td>
    <td><a href="https://github.com/TomerFi/aioswitcher/wiki">Wiki</a></td>
    <td><a href="https://github.com/TomerFi/aioswitcher/blob/dev/CONTRIBUTING.md">Contributing</a></td>
  </table>



  <details>
    <summary>State Bridge</summary>

  ```python
  async def print_devices(delay):
      def on_device_found_callback(device):
          
          print(asdict(device))

      async with SwitcherBridge(on_device_found_callback):
          await asyncio.sleep(delay)


  asyncio.run(print_devices(60))
  ```

  </details>

  <details>
    <summary>Power Plug API</summary>

    ```python
    async def control_power_plug(device_type, device_ip, device_id, device_key) :
        
        async with SwitcherType1Api(device_type, device_ip, device_id, device_key) as api:
            
            await api.get_state()
            
            await api.control_device(Command.ON)
            
            await api.control_device(Command.OFF)
            
            await api.set_device_name("my new name")

    asyncio.run(control_power_plug(DeviceType.POWER_PLUG, "111.222.11.22", "ab1c2d", "00"))
    ```

  </details>

  <details>
    <summary>Water Heater API</summary>

    ```python
    async def control_water_heater(device_type, device_ip, device_id, device_key) :
        
        async with SwitcherType1Api(device_type, device_ip, device_id, device_key) as api:
            
            await api.get_state()
            
            await api.control_device(Command.ON, 15)
            
            await api.control_device(Command.OFF)
            
            await api.set_device_name("my new name")
            
            await api.set_auto_shutdown(timedelta(hours=2, minutes=30))
            
            await api.get_schedules()
            
            await api.delete_schedule("1")
            
            
            await api.create_schedule("13:00", "14:30", {Days.SUNDAY, Days.FRIDAY})

    asyncio.run(control_water_heater(DeviceType.MINI, "111.222.11.22", "ab1c2d" , "00"))
    asyncio.run(control_water_heater(DeviceType.TOUCH, "111.222.11.22", "ab1c2d" , "00"))
    asyncio.run(control_water_heater(DeviceType.V2_ESP, "111.222.11.22", "ab1c2d" , "00"))
    asyncio.run(control_water_heater(DeviceType.V2_QCA, "111.222.11.22", "ab1c2d" , "00"))
    asyncio.run(control_water_heater(DeviceType.V4, "111.222.11.22", "ab1c2d" , "00"))
    ```

  </details>

  <details>
    <summary>Runner API</summary>

    ```python
    async def control_runner(device_type, device_ip, device_id, device_key, token) :
        
        async with SwitcherType2Api(device_type, device_ip, device_id, device_key, token) as api:
            
            await api.get_shutter_state()
            
            await api.set_position(30, 0)
            
            await api.stop_shutter(0)
            
            await api.api.set_light(DeviceState.ON, 0)
            
            await api.api.set_light(DeviceState.OFF, 0)

    asyncio.run(control_runner(DeviceType.RUNNER, "111.222.11.22", "ab1c2d", "00"))
    asyncio.run(control_runner(DeviceType.RUNNER_MINI, "111.222.11.22", "ab1c2d", "00"))
    asyncio.run(control_runner(DeviceType.RUNNER_S11, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    asyncio.run(control_runner(DeviceType.RUNNER_S12, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    ```

  </details>

  <details>
    <summary>Breeze API</summary>

    ```python
    async def control_breeze(device_type, device_ip, device_id, device_key, remote_manager, remote_id) :
        
        async with SwitcherType2Api(device_type, device_ip, device_id, device_key) as api:
            
            await api.get_breeze_state()
            
            remote = remote_manager.get_remote(remote_id)
            
            
            
            await api.control_breeze_device(
                remote,
                DeviceState.ON,
                ThermostatMode.COOL,
                24,
                ThermostatFanLevel.MEDIUM,
                ThermostatSwing.ON,
            )

    
    remote_manager = SwitcherBreezeRemoteManager()
    asyncio.run(control_breeze(DeviceType.BREEZE, "111.222.11.22", "ab1c2d", "00", remote_manager, "DLK65863"))
    ```

  </details>



  - [discover_devices.py](https://github.com/TomerFi/aioswitcher/blob/dev/scripts/discover_devices.py) can discover devices and their states (can be run by `poetry run discover_devices`).
  - [control_device.py](https://github.com/TomerFi/aioswitcher/blob/dev/scripts/control_device.py) can control a device (can be run by `poetry run control_device`).
  - [get_device_login_key.py](https://github.com/TomerFi/aioswitcher/blob/dev/scripts/get_device_login_key) can get a device login key (can be run by `poetry run get_device_login_key`).
  - [validate_token.py](https://github.com/TomerFi/aioswitcher/blob/dev/scripts/validate_token.py) can validate a device token which is a must for newer devices, used for communicating with devices (can be run by `poetry run validate_token`).



  This is **NOT** an official module and it is **NOT** officially supported by the vendor.</br>
  That said, thanks are in order to all the people at [Switcher][12] for their cooperation and general support.



  Thanks goes to these wonderful people ([emoji key][1]):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/aviadgolan"><img src="https://avatars.githubusercontent.com/u/17742111?v=4?s=100" width="100px;" alt="Aviad Golan"/><br /><sub><b>Aviad Golan</b></sub></a><br /><a href="#data-AviadGolan" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dolby360"><img src="https://avatars.githubusercontent.com/u/22151399?v=4?s=100" width="100px;" alt="Dolev Ben Aharon"/><br /><sub><b>Dolev Ben Aharon</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=dolby360" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://fabian-affolter.ch/blog/"><img src="https://avatars.githubusercontent.com/u/116184?v=4?s=100" width="100px;" alt="Fabian Affolter"/><br /><sub><b>Fabian Affolter</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=fabaff" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/oranja"><img src="https://avatars.githubusercontent.com/u/679184?v=4?s=100" width="100px;" alt="Itzik Ephraim"/><br /><sub><b>Itzik Ephraim</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=oranja" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Kesav890"><img src="https://avatars.githubusercontent.com/u/82559951?v=4?s=100" width="100px;" alt="Kesav890"/><br /><sub><b>Kesav890</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=Kesav890" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://liad.avrah.am"><img src="https://avatars.githubusercontent.com/u/7263223?v=4?s=100" width="100px;" alt="Liad Avraham"/><br /><sub><b>Liad Avraham</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=liadav" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/cdce8p"><img src="https://avatars.githubusercontent.com/u/30130371?v=4?s=100" width="100px;" alt="Marc Mueller"/><br /><sub><b>Marc Mueller</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=cdce8p" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/OrBin"><img src="https://avatars.githubusercontent.com/u/6897234?v=4?s=100" width="100px;" alt="Or Bin"/><br /><sub><b>Or Bin</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=OrBin" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/5c077m4n"><img src="https://avatars.githubusercontent.com/u/35409124?v=4?s=100" width="100px;" alt="Roeeeee"/><br /><sub><b>Roeeeee</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=5c077m4n" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://exploit.co.il"><img src="https://avatars.githubusercontent.com/u/1768915?v=4?s=100" width="100px;" alt="Shai rod"/><br /><sub><b>Shai rod</b></sub></a><br /><a href="#data-nightrang3r" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/thecode"><img src="https://avatars.githubusercontent.com/u/1858925?v=4?s=100" width="100px;" alt="Shay Levy"/><br /><sub><b>Shay Levy</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=thecode" title="Code">💻</a> <a href="#ideas-thecode" title="Ideas, Planning, & Feedback">🤔</a> <a href="#maintenance-thecode" title="Maintenance">🚧</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/YogevBokobza"><img src="https://avatars.githubusercontent.com/u/22839127?v=4?s=100" width="100px;" alt="YogevBokobza"/><br /><sub><b>YogevBokobza</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=YogevBokobza" title="Code">💻</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=YogevBokobza" title="Tests">⚠️</a> <a href="#maintenance-YogevBokobza" title="Maintenance">🚧</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/gmyuval"><img src="https://avatars.githubusercontent.com/u/28506179?v=4?s=100" width="100px;" alt="Yuval Moran"/><br /><sub><b>Yuval Moran</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=gmyuval" title="Code">💻</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=gmyuval" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ayal"><img src="https://avatars.githubusercontent.com/u/121446?v=4?s=100" width="100px;" alt="ayal"/><br /><sub><b>ayal</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/issues?q=author%3Aayal" title="Bug reports">🐛</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=ayal" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dmatik"><img src="https://avatars.githubusercontent.com/u/5577386?v=4?s=100" width="100px;" alt="dmatik"/><br /><sub><b>dmatik</b></sub></a><br /><a href="#blog-dmatik" title="Blogposts">📝</a> <a href="#ideas-dmatik" title="Ideas, Planning, & Feedback">🤔</a> <a href="#userTesting-dmatik" title="User Testing">📓</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/epenet"><img src="https://avatars.githubusercontent.com/u/6771947?v=4?s=100" width="100px;" alt="epenet"/><br /><sub><b>epenet</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/issues?q=author%3Aepenet" title="Bug reports">🐛</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=epenet" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jafar-atili"><img src="https://avatars.githubusercontent.com/u/19508787?v=4?s=100" width="100px;" alt="jafar-atili"/><br /><sub><b>jafar-atili</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=jafar-atili" title="Code">💻</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=jafar-atili" title="Documentation">📖</a></td>
      </tr>
    </tbody>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  <!-- Real Links -->
  [0]: https://github.com/TomerFi/aioswitcher/wiki
  [1]: https://allcontributors.org/docs/en/emoji-key
  [2]: https://allcontributors.org
  [3]: https://codecov.io/gh/TomerFi/aioswitcher
  [4]: https://github.com/TomerFi/aioswitcher
  [7]: https://github.com/TomerFi/aioswitcher/actions/workflows/stage.yml
  [8]: https://aioswitcher.tomfi.info/
  [11]: https://pypi.org/project/aioswitcher
  [12]: https://www.switcher.co.il/
  <!-- Badges Links -->
  [all-contributors]: https://img.shields.io/github/all-contributors/tomerfi/aioswitcher?color=ee8449&style=flat-square
  [codecov]: https://codecov.io/gh/TomerFi/aioswitcher/graph/badge.svg
  [gh-build-status]: https://github.com/TomerFi/aioswitcher/actions/workflows/stage.yml/badge.svg
  [gh-pages-status]: https://github.com/TomerFi/aioswitcher/actions/workflows/pages.yml/badge.svg
  [license-badge]: https://img.shields.io/github/license/tomerfi/aioswitcher
  [pypi-downloads]: https://img.shields.io/pypi/dm/aioswitcher.svg?logo=pypi&color=1082C2
  [pypi-version]: https://img.shields.io/pypi/v/aioswitcher?logo=pypi


pkgId: 098fab490473634fca89729bbb6dc4c079f2eb163e483d1f7ab90b96c4af279b
name: python-aioswitcher
arch: src
version: 5.1.0
epoch: 0
release: 1
summary: Switcher Python Integration.
url: https://pypi.org/project/aioswitcher/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioswitcher-5.1.0-1.src.rpm
checksum_type: sha256
description:
  [![gh-build-status]][7] [![gh-pages-status]][8] [![codecov]][3]

  PyPi module integrating with various [Switcher][12] devices.</br>
  Check out the [wiki pages][0] for a list of supported devices.

  ```shell
  pip install aioswitcher
  ```

  <table>
    <td><a href="https://aioswitcher.tomfi.info/">Documentation</a></td>
    <td><a href="https://github.com/TomerFi/aioswitcher/wiki">Wiki</a></td>
    <td><a href="https://github.com/TomerFi/aioswitcher/blob/dev/CONTRIBUTING.md">Contributing</a></td>
  </table>



  <details>
    <summary>State Bridge</summary>

  ```python
  async def print_devices(delay):
      def on_device_found_callback(device):
          
          print(asdict(device))

      async with SwitcherBridge(on_device_found_callback):
          await asyncio.sleep(delay)


  asyncio.run(print_devices(60))
  ```

  </details>

  <details>
    <summary>Power Plug API</summary>

    ```python
    async def control_power_plug(device_type, device_ip, device_id, device_key) :
        
        async with SwitcherApi(device_type, device_ip, device_id, device_key) as api:
            
            await api.get_state()
            
            await api.control_device(Command.ON)
            
            await api.control_device(Command.OFF)
            
            await api.set_device_name("my new name")

    asyncio.run(control_power_plug(DeviceType.POWER_PLUG, "111.222.11.22", "ab1c2d", "00"))
    ```

  </details>

  <details>
    <summary>Water Heater API</summary>

    ```python
    async def control_water_heater(device_type, device_ip, device_id, device_key) :
        
        async with SwitcherApi(device_type, device_ip, device_id, device_key) as api:
            
            await api.get_state()
            
            await api.control_device(Command.ON, 15)
            
            await api.control_device(Command.OFF)
            
            await api.set_device_name("my new name")
            
            await api.set_auto_shutdown(timedelta(hours=2, minutes=30))
            
            await api.get_schedules()
            
            await api.delete_schedule("1")
            
            
            await api.create_schedule("13:00", "14:30", {Days.SUNDAY, Days.FRIDAY})

    asyncio.run(control_water_heater(DeviceType.MINI, "111.222.11.22", "ab1c2d" , "00"))
    asyncio.run(control_water_heater(DeviceType.TOUCH, "111.222.11.22", "ab1c2d" , "00"))
    asyncio.run(control_water_heater(DeviceType.V2_ESP, "111.222.11.22", "ab1c2d" , "00"))
    asyncio.run(control_water_heater(DeviceType.V2_QCA, "111.222.11.22", "ab1c2d" , "00"))
    asyncio.run(control_water_heater(DeviceType.V4, "111.222.11.22", "ab1c2d" , "00"))
    ```

  </details>

  <details>
    <summary>Runner API</summary>

    ```python
    async def control_runner(device_type, device_ip, device_id, device_key, token) :
        
        async with SwitcherApi(device_type, device_ip, device_id, device_key, token) as api:
            
            await api.get_shutter_state(0)
            
            await api.set_position(30, 0)
            
            await api.stop_shutter(0)
            
            await api.set_light(DeviceState.ON, 0)
            
            await api.set_light(DeviceState.OFF, 0)

    asyncio.run(control_runner(DeviceType.RUNNER, "111.222.11.22", "ab1c2d", "00"))
    asyncio.run(control_runner(DeviceType.RUNNER_MINI, "111.222.11.22", "ab1c2d", "00"))
    asyncio.run(control_runner(DeviceType.RUNNER_S11, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    asyncio.run(control_runner(DeviceType.RUNNER_S12, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    ```

  </details>

  <details>
    <summary>Breeze API</summary>

    ```python
    async def control_breeze(device_type, device_ip, device_id, device_key, remote_manager, remote_id) :
        
        async with SwitcherApi(device_type, device_ip, device_id, device_key) as api:
            
            await api.get_breeze_state()
            
            remote = remote_manager.get_remote(remote_id)
            
            
            
            await api.control_breeze_device(
                remote,
                DeviceState.ON,
                ThermostatMode.COOL,
                24,
                ThermostatFanLevel.MEDIUM,
                ThermostatSwing.ON,
            )

    
    remote_manager = SwitcherBreezeRemoteManager()
    asyncio.run(control_breeze(DeviceType.BREEZE, "111.222.11.22", "ab1c2d", "00", remote_manager, "DLK65863"))
    ```

  </details>

  <details>
    <summary>Light API</summary>

    ```python
    async def control_light(device_type, device_ip, device_id, device_key, token) :
        
        async with SwitcherApi(device_type, device_ip, device_id, device_key, token) as api:
            
            await api.get_light_state(0)
            
            await api.set_light(DeviceState.ON, 0)
            
            await api.set_light(DeviceState.OFF, 0)

    asyncio.run(control_light(DeviceType.LIGHT_SL01, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    asyncio.run(control_light(DeviceType.LIGHT_SL01_MINI, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    asyncio.run(control_light(DeviceType.LIGHT_SL02, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    asyncio.run(control_light(DeviceType.LIGHT_SL02_MINI, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    asyncio.run(control_light(DeviceType.LIGHT_SL03, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    ```

  </details>



  - [discover_devices.py](https://github.com/TomerFi/aioswitcher/blob/dev/scripts/discover_devices.py) can discover devices and their states (can be run by `poetry run discover_devices`).
  - [control_device.py](https://github.com/TomerFi/aioswitcher/blob/dev/scripts/control_device.py) can control a device (can be run by `poetry run control_device`).
  - [get_device_login_key.py](https://github.com/TomerFi/aioswitcher/blob/dev/scripts/get_device_login_key) can get a device login key (can be run by `poetry run get_device_login_key`).
  - [validate_token.py](https://github.com/TomerFi/aioswitcher/blob/dev/scripts/validate_token.py) can validate a device token which is a must for newer devices, used for communicating with devices (can be run by `poetry run validate_token`).



  This is **NOT** an official module and it is **NOT** officially supported by the vendor.</br>
  That said, thanks are in order to all the people at [Switcher][12] for their cooperation and general support.



  Thanks goes to these wonderful people ([emoji key][1]):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/aviadgolan"><img src="https://avatars.githubusercontent.com/u/17742111?v=4?s=100" width="100px;" alt="Aviad Golan"/><br /><sub><b>Aviad Golan</b></sub></a><br /><a href="#data-AviadGolan" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dolby360"><img src="https://avatars.githubusercontent.com/u/22151399?v=4?s=100" width="100px;" alt="Dolev Ben Aharon"/><br /><sub><b>Dolev Ben Aharon</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=dolby360" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://fabian-affolter.ch/blog/"><img src="https://avatars.githubusercontent.com/u/116184?v=4?s=100" width="100px;" alt="Fabian Affolter"/><br /><sub><b>Fabian Affolter</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=fabaff" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/oranja"><img src="https://avatars.githubusercontent.com/u/679184?v=4?s=100" width="100px;" alt="Itzik Ephraim"/><br /><sub><b>Itzik Ephraim</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=oranja" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Kesav890"><img src="https://avatars.githubusercontent.com/u/82559951?v=4?s=100" width="100px;" alt="Kesav890"/><br /><sub><b>Kesav890</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=Kesav890" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://liad.avrah.am"><img src="https://avatars.githubusercontent.com/u/7263223?v=4?s=100" width="100px;" alt="Liad Avraham"/><br /><sub><b>Liad Avraham</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=liadav" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/cdce8p"><img src="https://avatars.githubusercontent.com/u/30130371?v=4?s=100" width="100px;" alt="Marc Mueller"/><br /><sub><b>Marc Mueller</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=cdce8p" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/OrBin"><img src="https://avatars.githubusercontent.com/u/6897234?v=4?s=100" width="100px;" alt="Or Bin"/><br /><sub><b>Or Bin</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=OrBin" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/5c077m4n"><img src="https://avatars.githubusercontent.com/u/35409124?v=4?s=100" width="100px;" alt="Roeeeee"/><br /><sub><b>Roeeeee</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=5c077m4n" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://exploit.co.il"><img src="https://avatars.githubusercontent.com/u/1768915?v=4?s=100" width="100px;" alt="Shai rod"/><br /><sub><b>Shai rod</b></sub></a><br /><a href="#data-nightrang3r" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/thecode"><img src="https://avatars.githubusercontent.com/u/1858925?v=4?s=100" width="100px;" alt="Shay Levy"/><br /><sub><b>Shay Levy</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=thecode" title="Code">💻</a> <a href="#ideas-thecode" title="Ideas, Planning, & Feedback">🤔</a> <a href="#maintenance-thecode" title="Maintenance">🚧</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/YogevBokobza"><img src="https://avatars.githubusercontent.com/u/22839127?v=4?s=100" width="100px;" alt="YogevBokobza"/><br /><sub><b>YogevBokobza</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=YogevBokobza" title="Code">💻</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=YogevBokobza" title="Tests">⚠️</a> <a href="#maintenance-YogevBokobza" title="Maintenance">🚧</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/gmyuval"><img src="https://avatars.githubusercontent.com/u/28506179?v=4?s=100" width="100px;" alt="Yuval Moran"/><br /><sub><b>Yuval Moran</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=gmyuval" title="Code">💻</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=gmyuval" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ayal"><img src="https://avatars.githubusercontent.com/u/121446?v=4?s=100" width="100px;" alt="ayal"/><br /><sub><b>ayal</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/issues?q=author%3Aayal" title="Bug reports">🐛</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=ayal" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dmatik"><img src="https://avatars.githubusercontent.com/u/5577386?v=4?s=100" width="100px;" alt="dmatik"/><br /><sub><b>dmatik</b></sub></a><br /><a href="#blog-dmatik" title="Blogposts">📝</a> <a href="#ideas-dmatik" title="Ideas, Planning, & Feedback">🤔</a> <a href="#userTesting-dmatik" title="User Testing">📓</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/epenet"><img src="https://avatars.githubusercontent.com/u/6771947?v=4?s=100" width="100px;" alt="epenet"/><br /><sub><b>epenet</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/issues?q=author%3Aepenet" title="Bug reports">🐛</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=epenet" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jafar-atili"><img src="https://avatars.githubusercontent.com/u/19508787?v=4?s=100" width="100px;" alt="jafar-atili"/><br /><sub><b>jafar-atili</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=jafar-atili" title="Code">💻</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=jafar-atili" title="Documentation">📖</a></td>
      </tr>
    </tbody>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  <!-- Real Links -->
  [0]: https://github.com/TomerFi/aioswitcher/wiki
  [1]: https://allcontributors.org/docs/en/emoji-key
  [2]: https://allcontributors.org
  [3]: https://codecov.io/gh/TomerFi/aioswitcher
  [4]: https://github.com/TomerFi/aioswitcher
  [7]: https://github.com/TomerFi/aioswitcher/actions/workflows/stage.yml
  [8]: https://aioswitcher.tomfi.info/
  [11]: https://pypi.org/project/aioswitcher
  [12]: https://www.switcher.co.il/
  <!-- Badges Links -->
  [all-contributors]: https://img.shields.io/github/all-contributors/tomerfi/aioswitcher?color=ee8449&style=flat-square
  [codecov]: https://codecov.io/gh/TomerFi/aioswitcher/graph/badge.svg
  [gh-build-status]: https://github.com/TomerFi/aioswitcher/actions/workflows/stage.yml/badge.svg
  [gh-pages-status]: https://github.com/TomerFi/aioswitcher/actions/workflows/pages.yml/badge.svg
  [license-badge]: https://img.shields.io/github/license/tomerfi/aioswitcher
  [pypi-downloads]: https://img.shields.io/pypi/dm/aioswitcher.svg?logo=pypi&color=1082C2
  [pypi-version]: https://img.shields.io/pypi/v/aioswitcher?logo=pypi


pkgId: c10ea7a151b8441043a7e9f51fcc8c0fa0eb4d36cc62fef2702a4b1af48a5cbd
name: python-aiosyncthing
arch: src
version: 0.6.3
epoch: 0
release: 1
summary: Asynchronous Python client for the Syncthing REST API
url: https://github.com/zhulik/aiosyncthing
rpm_license: The MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosyncthing-0.6.3-1.src.rpm
checksum_type: sha256
description:
  ![Continuous Integration](https://github.com/zhulik/aiosyncthing/workflows/Continuous%20Integration/badge.svg?branch=master)

  Asynchronous Python client for the [Syncthing](https://syncthing.net/) [REST API](https://docs.syncthing.net/dev/rest.html).

  Inspired by [python-syncthing](https://github.com/blakev/python-syncthing),
  some snippets were copied from [python-fumis](https://github.com/frenck/python-fumis)

  NOTE: The package is in active development. *Not all features of the API are implemented.*



  `pip install aiosyncthing`



  ```python
  import asyncio

  from aiosyncthing import Syncthing

  async def main():

    async with Syncthing("API Key") as client:
      
      pass

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



  Syncthing is the entrypoint class, it acts as an async context manager and provides access to endpoint namespaces.



  ```python
      def __init__(
          self,
          api_key, # your API Key
          url="http://127.0.0.1:8384", # A base URL of the server, https://syncthing.example.com:443/something is also possible
          timeout=DEFAULT_TIMEOUT, # Timeout in seconds
          verify_ssl=True, # Perform SSL verification
          loop=None, # event loop
          session=None # client session,
      )...
  ```

  In case if the api_key is invalid, `aiosyncthing.exceptions.SyncthingError` will be raised on attempt to perform any request except `client.system.ping()`, this one only raises `aiosyncthing.exceptions.PingError`.



  Provides access to the [System Endpoints](https://docs.syncthing.net/dev/rest.html#system-endpoints)


  Returns none if ping is successful or raises `syncthing.exceptions.PingError`

  ```python
  await client.system.ping()
  ```


  Returns a dict with the server config or raises `syncthing.exceptions.SyncthingError`

  ```python
  await client.system.config()
  ```


  Returns a dict with the server status or raises `syncthing.exceptions.SyncthingError`

  ```python
  await client.system.status()
  ```


  Returns a dict with the server version or raises `syncthing.exceptions.SyncthingError`

  ```python
  await client.system.version()
  ```


  Pauses synchronization with all devices or with the selected device or raises `syncthing.exceptions.SyncthingError`,
  in case if passed devices is unknown to the server, `syncthing.exceptions.UnknownDeviceError` will be raised. Always returns `None`

  ```python
  await client.system.pause() # pause all
  await client.system.pause(device_id) # eg: 'MTLMICV-YE72URC-NF4LBO3-2LVPTFZ-LLCZHEZ-2F3OEJS-R6CWZVE-7VXHFQA"
  ```


  Resumes synchronization with all devices or with a selected device or raises `syncthing.exceptions.SyncthingError`,
  in case if passed devices is unknown to the server, `syncthing.exceptions.UnknownDeviceError` will be raised. Always returns `None`

  ```python
  await client.system.resume() # resume all
  await client.system.resume(device_id) # eg: 'MTLMICV-YE72URC-NF4LBO3-2LVPTFZ-LLCZHEZ-2F3OEJS-R6CWZVE-7VXHFQA"
  ```


  Provides access to the [Database Endpoints](https://docs.syncthing.net/dev/rest.html#database-endpoints)


  Returns a dict with the folder status or raises `syncthing.exceptions.SyncthingError`. If the folder id is unknown to
  the server, `syncthing.exceptions.UnknownFolderError` will be raised.

  ```python
  await client.database.status(folder_id) # eg: 'GXWxf-3zgnU'
  ```


  Provides access to the [Events Endpoints](https://docs.syncthing.net/dev/rest.html#event-endpoints)


  Is an async generator function that listens to the [Event API](https://docs.syncthing.net/dev/events.html), yields events one by one and hides the complexity of long polling.
  Raises `syncthing.exceptions.SyncthingError` in case of error, handles timeouts internally and reconnects to the
  endpoint.


  ```python
  async for event in client.events.listen():
    print(event)
  ```


  Returns the id of the last received event of the previous batch.

  ```python
  async for event in client.events.listen():
    if events.last_seen_id == 0:
      continue # skip first batch because it's historical data
  ```



  MIT License

  Copyright (c) 2020 Gleb Sinyavskiy

  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.


pkgId: 0c19c596369a1a02f572421939ac0333db5cf6ff66bb7670173ad960f58e58e6
name: python-aiosysbus
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: Provides asynchronous authentication and access to Livebox
url: https://pypi.org/project/aiosysbus/
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiosysbus-1.1.8-1.src.rpm
checksum_type: sha256
description:
  Manage your Livebox in Python

  Easily manage your Livebox in Python.
  Check your config, configure your dhcp, disable your wifi, monitor your LAN activity and many others, on LAN or remotely.

  aiosysbus is a python library implementing fir the Livebox v3.

  This project is based on stilllman/aiofreepybox, which provides the same features as aiofreepybox in a synchronous manner.



  **Version 1.0.0 and above** makes all these calls asynchronously.
  It breaks the compatibility of previous codes



  Use the PIP package manager

  ```bash
  $ pip install aiosysbus
  ```

  Or manually download and install the last version from github

  ```bash
  $ git clone https://github.com/cyr-ius/aiosysbus.git
  $ python setup.py install
  ```



  aiosysbus < 1.0.0

  ```python

  from aiosysbus import AIOSysbus

  async def reboot()
      
      lvbx = AIOSysbus('192.168.1.1','80','xxxxxx')

      
      lvbx.connect()

      
      lvbx.system.reboot()

      
      lvbx.close()
  ```

  aiosysbus >= 1.0.0

  ```python
  import asyncio
  import logging

  async def async_main() -> None:
      
      api = AIOSysbus(username=xxxx, password=xxxx, host=HOST)
      
      await api.async_connect()
      
      parameters = {"parameters": {"expression": {"wifi": "wifi && .Active==False"}}}
      devices = await api.devices.async_get_devices(parameters)

      await api.async_close()

  if __name__ == "__main__":
      loop = asyncio.get_event_loop()
      loop.run_until_complete(async_main())
  ```

  Have a look at the [example.py](https://github.com/cyr-ius/aiosysbus/blob/master/example.py) for a more complete overview.



  Not implemented


pkgId: 0dec0785a0dbf2fe3b17e36773f7eb78990838d36b715654007f73da85c2324a
name: python-aiota2
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Asynchronous python interface for <OPENDOTA/> API
url: https://github.com/FilinSep/aiota2
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiota2-1.0.2-1.src.rpm
checksum_type: sha256
description:
  ![enter image description here](https://img.shields.io/pypi/v/aiota2?color=success)![enter image description here](https://img.shields.io/pypi/pyversions/aiota2)![enter image description here](https://img.shields.io/github/followers/FilinSep?style=social)![enter image description here](https://img.shields.io/github/issues/FilinSep/aiota2)

  Asynchronous python interface for \<OPENDOTA/> API

  * A function for each API call
  * Asynchrony support
  * Allows API keys authentication
  * Abstract Models class


  ```python
  from aiota2 import AioClient
  import asyncio

  async def main():
    
    dota = AioClient()

  asyncio.run(main=main())
  ```
  Get player / match / team / heroes
  ```python
  await dota.get_player(account_id: int)
  await dota.get_match(match_id: int)
  await dota.get_team(team_id: int)
  await dota.get_heroes()
  ```

  ```python
  await dota.search_player_by_personaname(**query_params)
  await dota.find_matches(**query_params)
  await dota.get_teams(**query_params)

  ```

  That give you ability to access the dota heroes base without sending a request to API many times, just use object attribute "heroes"
  ```python
  from aiota2 import AioClient
  import asyncio

  async def main():
      
      dota = await AioClient().load_heroes() # Pay attention to await
      

  asyncio.run(main=main())
  ```
  So that allows you:
  ```python
  dota.heroes
  dota.get_hero_by_param(param: str, value: Any)
  dota.get_heroes_by_param(param: str, value: Any)
  ```

  Using DataModel
  ```python
  from aiota2 import AioClient
  import asyncio

  async def main():
    
    dota = AioClient(with_models=True)

  asyncio.run(main=main())
  ```
  ```python
  >>> answer = await dota.get_player(player_id: int)
  <DataModel of Player at address>
  >>> answer.rank_tier
  0
  ```

  Creating DataModel
  ```python
  from aiota2 import DataModel

  colors = {
      "sky": "blue",
      "grass": "green"
  }

  model = DataModel("colors", colors)
  ```

  The OpenDota API provides Dota 2 related data including advanced match data extracted from match replays.

  OpenDota API Documentation: https://docs.opendota.com/


  This package uses data provided by The OpenDota API.


pkgId: 4e0456481eae656fda4cb81385e777235f30c671f21a73aaf50c7b741c6e36b3
name: python-aiotailwind
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A small example package
url: https://github.com/pauln/aiotailwind
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotailwind-0.1.1-1.src.rpm
checksum_type: sha256
description:
  asyncio library to interact with [Tailwind](https://gotailwind.com) devices using their [local JSON API](https://github.com/Scott--R/Tailwind_Local_Control_API).



  In order to use the local control API, it's necessary to obtain your Local Control Key (a 6-digit code), which you then provide when initialising an `Auth` instance.

  To obtain your Local Control Key, ensure that you've updated your Tailwind iQ3 to the v9.95 firmware or later, and then:

  1. Visit [Tailwind Web](https://web.gotailwind.com)
  2. Log in with your Tailwind account
  3. Click "Local Control Key" in the top menu (red box in screenshot)
  4. If no key is displayed, click the "Create new local command key" button
  5. Enter the 6-digit code (green box in screenshot) into the integration configuration

  ![Screenshot showing where to find the Local Control Key](local_control_key.png)



  This library has been developed and tested against a Tailwind iQ3 garage door opener controller.  A rudimentary attempt to support the Light device referenced in the API documentation has been made, but without access to a physical device, it has not been possible to test whether this works.



  See [demo.py](https://github.com/pauln/aiotailwind/blob/main/demo.py) for a basic demo.


pkgId: 2a244cb2bb9249ec19fd773084d90cb6d937b77beee2edd437a002669b2d7a8e
name: python-aiotainer
arch: src
version: 0.0.1b5
epoch: 0
release: 1
summary: MPython module to talk to a Portainer.
url: https://github.com/Thomas55555/aiotainer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotainer-0.0.1b5-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/Thomas55555/aiotainer/graph/badge.svg?token=Hn1Qp8ZvOt)](https://codecov.io/gh/Thomas55555/aiotainer)
  [![Python Versions](https://img.shields.io/pypi/pyversions/aiotainer)](https://pypi.org/project/aiotainer/)
  [![License](https://img.shields.io/github/license/Thomas55555/aiotainer.svg)](LICENSE.md)

  Asynchronous library to communicate with the Portainer API



  In order to use the library, you'll need to do some work yourself to get authentication
  credentials. This depends a lot on the context (e.g. redirecting to use OAuth via web)
  but should be easy to incorporate using Portainers's authentication examples. See
  Portainers's [Authentication](https://docs.portainer.io/admin/settings/authentication) for details.

  You will implement `AbstractAuth` to provide an access token. Your implementation
  will handle any necessary refreshes. You can invoke the service with your auth implementation
  to access the API.

  You need at least:

  - Python 3.11+
  - [Poetry][poetry-install]

  For a first start you can run the `example.py`, by doing the following steps

  - `git clone https://github.com/Thomas55555/aiotainer.git`
  - `cd aiotainer`
  - `poetry install`
  - Enter your personal `client_id` and `client_secret` in the `_secrets.yaml` and rename it to `secrets.yaml`
  - Run with `poetry run ./example.py`



  This is an active open-source project. We are always open to people who want to use the code or contribute to it.
  This Python project is fully managed using the [Poetry][poetry] dependency manager.

  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
  ```

  To update snapshots:

  ```bash
  poetry run pytest --snapshot-update
  ```

  [poetry-install]: https://python-poetry.org/docs/#installation
  [poetry]: https://python-poetry.org
  [pre-commit]: https://pre-commit.com/


