# packages

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

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

  Asynchronous Python client for tankerkoenig.de.



  This package allows you to fetch data from tankerkoenig.de.



  ```bash
  pip install aiotankerkoenig
  ```


  ```python
  import asyncio

  from aiotankerkoenig import Tankerkoenig


  async def main() -> None:
      """Run the example."""
      async with Tankerkoenig(api_key="abc123") as tk:
          station_details = await tk.station_details("12345678-1234-1234-1234-123456789012")

          print(f"Name: {station_details.name}")


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




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

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

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



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

  Thank you for being involved! :heart_eyes:



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

  You need at least:

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

  To install all packages, including all development requirements:

  ```bash
  npm install
  poetry install
  ```

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

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

  To run just the Python tests:

  ```bash
  poetry run pytest
  ```



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

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



  MIT License

  Copyright (c) 2024 Jan-Philipp Benecke

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

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

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

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


pkgId: f2be003c135d47c585a90605f7c6671b57704fec355ea44b396357713255f59f
name: python-aiotdlib
arch: src
version: 0.24.3
epoch: 0
release: 1
summary: Python asyncio Telegram client based on TDLib
url: https://github.com/pylakey/aiotdlib
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotdlib-0.24.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version shields.io](https://img.shields.io/pypi/v/aiotdlib.svg)](https://pypi.python.org/pypi/aiotdlib/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/aiotdlib.svg)](https://pypi.python.org/pypi/aiotdlib/)
  [![PyPI license](https://img.shields.io/pypi/l/aiotdlib.svg)](https://pypi.python.org/pypi/aiotdlib/)

  > [!WARNING]
  > This library is still in development, so any updates before version 1.0.0 may include breaking changes. Please be cautious and pin the library version when using it. If you wish to update, I recommend reviewing the Git commit history.

  > This wrapper is actual
  > for **[TDLib v1.8.31](https://github.com/tdlib/td/commit/8f19c751dc296cedb9a921badb7a02a8c0cb1aeb)**
  >
  > This package includes prebuilt TDLib binaries for macOS (arm64) and Debian (amd64).
  > You can use your own binary by passing `library_path` argument to `Client` class constructor. Make sure it's built
  > from [this commit](https://github.com/tdlib/td/commit/8f19c751dc296cedb9a921badb7a02a8c0cb1aeb). Compatibility with
  > other versions of library is not guaranteed.



  * All types and functions are generated automatically
    from [tl schema](https://github.com/tdlib/td/blob/8f19c751dc296cedb9a921badb7a02a8c0cb1aeb/td/generate/scheme/td_api.tl)
  * All types and functions come with validation and good IDE type hinting (thanks
    to [Pydantic](https://github.com/samuelcolvin/pydantic))
  * A set of high-level API methods which makes work with tdlib much simpler



  * Python 3.9+
  * Get your **api_id** and **api_hash**. Read more
    in [Telegram docs](https://core.telegram.org/api/obtaining_api_id#obtaining-api-id)





  ```shell
  pip install aiotdlib
  ```

  or if you use [Poetry](https://python-poetry.org)

  ```shell
  poetry add aiotdlib
  ```





  ```python
  import asyncio
  import logging

  from aiotdlib import Client, ClientSettings

  API_ID = 123456
  API_HASH = ""
  PHONE_NUMBER = ""


  async def main():
      client = Client(
          settings=ClientSettings(
              api_id=API_ID,
              api_hash=API_HASH,
              phone_number=PHONE_NUMBER
          )
      )

      async with client:
          me = await client.api.get_me()
          logging.info(f"Successfully logged in as {me.model_dump_json()}")


  if __name__ == '__main__':
      logging.basicConfig(level=logging.INFO)
      asyncio.run(main())
  ```

  Any parameter of Client class could be also set via environment variables with prefix `AIOTDLIB_*`.

  ```python
  import asyncio
  import logging

  from aiotdlib import Client


  async def main():
      async with Client() as client:
          me = await client.api.get_me()
          logging.info(f"Successfully logged in as {me.model_dump_json()}")


  if __name__ == '__main__':
      logging.basicConfig(level=logging.INFO)
      asyncio.run(main())
  ```

  and run it like this:

  ```shell
  export AIOTDLIB_API_ID=123456
  export AIOTDLIB_API_HASH=<my_api_hash>
  export AIOTDLIB_BOT_TOKEN=<my_bot_token>
  python main.py
  ```



  ```python
  import asyncio
  import logging

  from aiotdlib import Client, ClientSettings
  from aiotdlib.api import API, BaseObject, UpdateNewMessage

  API_ID = 123456
  API_HASH = ""
  PHONE_NUMBER = ""


  async def on_update_new_message(client: Client, update: UpdateNewMessage):
      chat_id = update.message.chat_id

      
      chat = await client.api.get_chat(chat_id)
      logging.info(f'Message received in chat {chat.title}')


  async def any_event_handler(client: Client, update: BaseObject):
      logging.info(f'Event of type {update.ID} received')


  async def main():
      client = Client(
          settings=ClientSettings(
              api_id=API_ID,
              api_hash=API_HASH,
              phone_number=PHONE_NUMBER
          )
      )

      
      
      client.add_event_handler(on_update_new_message, update_type=API.Types.UPDATE_NEW_MESSAGE)

      
      
      client.add_event_handler(any_event_handler, update_type=API.Types.ANY)

      async with client:
          
          await client.idle()


  if __name__ == '__main__':
      logging.basicConfig(level=logging.INFO)
      asyncio.run(main())
  ```



  ```python
  import logging

  from aiotdlib import Client, ClientSettings
  from aiotdlib.api import UpdateNewMessage

  API_ID = 123456
  API_HASH = ""
  BOT_TOKEN = ""

  bot = Client(
      settings=ClientSettings(
          api_id=API_ID,
          api_hash=API_HASH,
          bot_token=BOT_TOKEN
      )
  )



  @bot.bot_command_handler(command='help')
  async def on_help_command(client: Client, update: UpdateNewMessage):
      
      
      await client.send_text(update.message.chat_id, "I will help you!")


  async def on_start_command(client: Client, update: UpdateNewMessage):
      
      print(update.EXTRA)
      await client.send_text(update.message.chat_id, "Have a good day! :)")


  async def on_custom_command(client: Client, update: UpdateNewMessage):
      
      
      print(update.EXTRA)


  if __name__ == '__main__':
      logging.basicConfig(level=logging.INFO)
      
      bot.bot_command_handler(on_start_command, command='start')
      bot.bot_command_handler(on_custom_command, command='custom')
      bot.run()
  ```



  ```python

  import asyncio
  import logging

  from aiotdlib import Client
  from aiotdlib import ClientSettings
  from aiotdlib import ClientProxySettings
  from aiotdlib import ClientProxyType

  API_ID = 123456
  API_HASH = ""
  PHONE_NUMBER = ""


  async def main():
      client = Client(
          settings=ClientSettings(
              api_id=API_ID,
              api_hash=API_HASH,
              phone_number=PHONE_NUMBER,
              proxy_settings=ClientProxySettings(
                  host="10.0.0.1",
                  port=3333,
                  type=ClientProxyType.SOCKS5,
                  username="aiotdlib",
                  password="somepassword",
              )
          )
      )

      async with client:
          await client.idle()


  if __name__ == '__main__':
      logging.basicConfig(level=logging.INFO)
      asyncio.run(main())
  ```



  ```python

  import asyncio
  import logging

  from aiotdlib import Client, HandlerCallable, ClientSettings
  from aiotdlib.api import API, BaseObject, UpdateNewMessage

  API_ID = 12345
  API_HASH = ""
  PHONE_NUMBER = ""


  async def some_pre_updates_work(event: BaseObject):
      logging.info(f"Before call all update handlers for event {event.ID}")


  async def some_post_updates_work(event: BaseObject):
      logging.info(f"After call all update handlers for event {event.ID}")




  async def my_middleware(client: Client, event: BaseObject, /, *, call_next: HandlerCallable):
      
      await some_pre_updates_work(event)

      try:
          await call_next(client, event)
      finally:
          await some_post_updates_work(event)


  async def on_update_new_message(client: Client, update: UpdateNewMessage):
      logging.info('on_update_new_message handler called')


  async def main():
      client = Client(
          settings=ClientSettings(
              api_id=API_ID,
              api_hash=API_HASH,
              phone_number=PHONE_NUMBER
          )
      )

      client.add_event_handler(on_update_new_message, update_type=API.Types.UPDATE_NEW_MESSAGE)

      
      
      
      
      
      client.add_middleware(my_middleware)

      async with client:
          await client.idle()


  if __name__ == '__main__':
      logging.basicConfig(level=logging.INFO)
      asyncio.run(main())
  ```



  This project is licensed under the terms of the [MIT](https://github.com/pylakey/aiotdlib/blob/master/LICENSE) license.

rpm_license:
  MIT License  Copyright (c) 2021 pylakey  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: 8effaace2f1ba21e10f911129d3722dab9371e663361850a568b6c357092b160
name: python-aiotedee
arch: src
version: 0.2.21
epoch: 0
release: 1
summary: A package to interact with Tedee locks using asyncio
url: https://github.com/zweckj/aiotedee
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotedee-0.2.21-1.src.rpm
checksum_type: sha256
description:
  This is a Tedee Lock Client package. It is an async implementation of [joerg65's original package](https://github.com/joerg65/pytedee.git).





  ```
  pip install aiotedee
  ```



  ```python
  pipenv install -e .

  python3 setup.py install
  ```



  - Generate personal key. Instructions: https://tedee-tedee-api-doc.readthedocs-hosted.com/en/latest/howtos/authenticate.html#personal-access-key
    Minimal scopes required for enable integration are:
    - Devices.Read
    - Lock.Operate
  - with `example.py`: Create a file `config.json` next to `example.py`:

  ```json
  {
    "personalToken": "<your token>"
  }
  ```

  cd into the directory of those to files and run

  ```
  python example.py
  ```

  - Initiate an instance of `TedeeClient`

  ```python
  from aiotedee import TedeeClient

  pk = "<your PersonalKey>"

  client = TedeeClient(pk) # is initialized with no locks
  client.get_locks() # get the locks



  client = await TedeeClient.create(pk)
  ```

  - the locks are avialable in a dictionary `client.locks_dict` with the key of the dict being the serial number of each lock, or in a list `client.locks`


pkgId: d1bc333655c9735986d6d456e2da053e6e2dff50fd62f66387280fc0b2e5e9a2
name: python-aiotfm
arch: src
version: 1.4.9
epoch: 0
release: 1
summary: An asynchronous event based client for Transformice
url: https://github.com/Athesdrake/aiotfm
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotfm-1.4.9-1.src.rpm
checksum_type: sha256
description:
  aiotfm is an asynchronous Client implementation of [Transformice](https://www.transformice.com/) that allows developers to make bots easily.
  It uses an API endpoint to get the keys needed to connect to the game.
  aiotfm is based on [TransFromage](https://github.com/Tocutoeltuco/transfromage) which use threads instead of coroutines.

  If you prefer Lua over Python then checkout the [Lua version](https://github.com/Lautenschlager-id/Transfromage) made by [@Lautenschlager-id](https://github.com/Lautenschlager-id)

  Join the **_[Fifty Shades of Lua](https://discord.gg/qmdryEB)_** [discord](https://discordapp.com/) server to discuss about this API and to receive special support.



  This API depends on an [endpoint](https://api.tocu.tk/get_transformice_keys.php) that gives you access to the Transformice encryption keys.

  To use it you will need a token which you can get by [applying through this form](https://forms.gle/N6Et1hLGQ9hmg95F6). See below to know the names of Transfromage managers who handle the token system.
  - **[Tocutoeltuco](https://github.com/Tocutoeltuco)** @discord=> `Tocu#0018` <sub>`212634414021214209`</sub>;
  - **[Blank3495](https://github.com/Blank3495)** @discord=> `󠂪󠂪 󠂪󠂪 󠂪󠂪󠂪󠂪 󠂪󠂪 󠂪󠂪󠂪󠂪 󠂪󠂪 󠂪󠂪#8737` <sub>`436703225140346881`</sub>;
  - **[Bolodefchoco](https://github.com/Lautenschlager-id)** @discord=> `Lautenschlager#2555` <sub>`285878295759814656`</sub>.



  - 3 times faster than TransFromage
  - Compatible with discord.py
  - Faster
  - Asynchronous



  TransFromage takes around 13 seconds to be connected to the community platform while aiotfm takes less than 4 seconds.
  Those results can vary depending on your computer and your internet connection.



  You can install aiotfm using pip:
  `pip install aiotfm`

  To have a more up to date package, you have to clone this repository and install it manually:
  ```sh
  git clone https://github.com/Athesdrake/aiotfm
  cd aiotfm
  python3 -m pip install .
  ```



  aiotfm require python 3.7 or higher and [aiohttp](https://github.com/aio-libs/aiohttp).



  Python 3.6 support is not guaranteed since [v1.4.3](https://github.com/Athesdrake/aiotfm/releases/tag/v1.4.3) as Python 3.6 has reached EOF.



  You can still use aiotfm with Python 3.5.3 or higher by cloning the repository and remove the sugar syntax of Python 3.6.
  These changes are the typed variables and fstrings.
  Due to a major update in the asynchronous stuff of Python 3.5.3, aiotfm is not compatible with the previous versions of Python.



  To update aiotfm, use the following command:
  `pip install -U aiotfm`



  ```Python
  import aiotfm

  bot = aiotfm.Client()


  @bot.event
  async def on_ready():
  	print('Connected to the community platform.')

  bot.run("api_tfmid", "api_token", "username", "password", encrypted=False, room="start_room")
  ```

  [A more complete example.](https://github.com/Athesdrake/aiotfm/blob/master/example_bot.py)



  You can find the documentation of aiotfm [here](https://github.com/Athesdrake/aiotfm/tree/master/docs).



  You can have more information about TransFromage in this [thread](https://atelier801.com/topic?f=5&t=917024).

rpm_license:
  MIT License  Copyright (c) 2019-2022 AthesDrake  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: 180417c56f317720fcc4b26ef3b2e41883f90c613f53e21a8864e688cd8922ac
name: python-aiotg
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Asynchronous Python API for building Telegram bots
url: http://szastupov.github.io/aiotg
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotg-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Asynchronous Python API for building Telegram bots, featuring:
  - Easy and declarative API
  - Hassle-free setup - no need for SSL certificates or static IP
  - Built-in support for analytics via chatbase.com
  - Automatic handling of Telegram API throttling or timeouts
  Install it with pip:
      pip install aiotg
  Then you can create a new bot in few lines:
      from aiotg import Bot, Chat
      bot = Bot(api_token="...")
      @bot.command(r"/echo (.+)")
      def echo(chat: Chat, match):
          return chat.reply(match.group(1))
      bot.run()
  Now run it with a proper API\_TOKEN and it should reply to /echo commands.
  The example above looks like a normal synchronous code but it actually returns a coroutine.
  If you want to make an external request (and that's what bots usually do) just use aiohttp and async/await syntax:
      import aiohttp
      from aiotg import Bot, Chat
      bot = Bot(api_token="...")
      @bot.command("bitcoin")
      async def bitcoin(chat: Chat, match):
          url = "https://apiv2.bitcoinaverage.com/indices/global/ticker/BTCUSD"
          async with aiohttp.ClientSession() as session:
              response = await session.get(url)
              info = await response.json()
              await chat.send_text(str(info["averages"]["day"]))
      bot.run()
  But what if you just want to write a quick integration and don't need to provide a conversational interface? We've got you covered!
  You can send messages (or any other media) by constructing a Chat object with user_id or channel name. We even saved you some extra keystrokes by providing handy Channel constructors:
      channel = bot.channel("@yourchannel")
      private = bot.private("1111111")
      async def greeter():
          await channel.send_text("Hello from channel!")
          await private.send_text("Why not greet personally?")


pkgId: 7ab919e1a53fef90a10bc5283b49bc1d5121c096ba69e10294dab5ba843f8637
name: python-aiotgm
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/aiotgm/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotgm-0.5.2-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/badge/pypi-aiotgm-blue)](https://pypi.org/project/aiotgm/) [![tele](https://img.shields.io/badge/telegram-@geko1-blue)](https://t.me/geko1) [![Documentation Status](https://readthedocs.org/projects/aiotgm/badge/?version=latest)](https://aiotgm.readthedocs.io/?badge=latest)

  <h3 align="center">Asynchronous python implementation of the Telegram Bot API <a href="https://core.telegram.org/bots/api#september-6-2024">7.10</a></h3>



  * #### Prerequisites
  You require a good python knowledge with the [asyncio module](https://docs.python.org/3/library/asyncio.html) and a Telegram Bot API token, you can get it via [@BotFather](https://t.me/botfather).



  * #### Dependencies
    * Python >= 3.8
    * [aiohttp](https://github.com/aio-libs/aiohttp)
    * Optional [ujson](https://github.com/ultrajson/ultrajson) & [certifi](https://github.com/certifi/python-certifi)



  * #### Installation

  Install the module using [pip](https://pypi.org/project/aiotgm/) with your shell.

  ```powershell
  $ pip install aiotgm
  ```

  Update the module regurarly with the following command.

  ```powershell
  $ pip install -U aiotgm
  ```



  * #### Documentation
  Here it is the [official documentation](https://aiotgm.readthedocs.io/).

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


pkgId: 4ad2b6df29dc31e41272aee2ec67e7bc1a4a69659783cc01d02d6331f92dae6f
name: python-aiotgm
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/aiotgm/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotgm-0.5.3-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/badge/pypi-aiotgm-blue)](https://pypi.org/project/aiotgm/) [![tele](https://img.shields.io/badge/telegram-@geko1-blue)](https://t.me/geko1) [![Documentation Status](https://readthedocs.org/projects/aiotgm/badge/?version=latest)](https://aiotgm.readthedocs.io/?badge=latest)

  <h3 align="center">Asynchronous python implementation of the Telegram Bot API <a href="https://core.telegram.org/bots/api#october-31-2024">7.11</a></h3>



  * #### Prerequisites
  You require a good python knowledge with the [asyncio module](https://docs.python.org/3/library/asyncio.html) and a Telegram Bot API token, you can get it via [@BotFather](https://t.me/botfather).



  * #### Dependencies
    * Python >= 3.8
    * [aiohttp](https://github.com/aio-libs/aiohttp)
    * Optional [ujson](https://github.com/ultrajson/ultrajson) & [certifi](https://github.com/certifi/python-certifi)



  * #### Installation

  Install the module using [pip](https://pypi.org/project/aiotgm/) with your shell.

  ```powershell
  $ pip install aiotgm
  ```

  Update the module regurarly with the following command.

  ```powershell
  $ pip install -U aiotgm
  ```



  * #### Documentation
  Here it is the [official documentation](https://aiotgm.readthedocs.io/).

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


pkgId: 0cc95daabee26a2b9737f7ff2298bf8d446e5c953e64ef92a413be1a70804b05
name: python-aiothornode
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: THORChain node connection library for Python
url: https://github.com/tirinox/aiothornode
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiothornode-0.1.7-1.src.rpm
checksum_type: sha256
description:
  This is a simple Python library to access [THORChain](https://thorchain.org/) nodes. It is asynchronous and uses _aiohttp_.



  v.0.1.0 breaking changes:
  1. NamedTuples instead of DataClasses for Thor entities
  2. Environments were renamed
  3. No more consensus features

  v.0.0.21 is hotfix. Port 1317 was disabled, so it is an emergency upgrade to save this lib. More news will be later...



  * Now it is just a convenient wrapper for THORNode API



  * Constants
  * Mimir
  * Nodes (node accounts)
  * Current TX queue length
  * Pools (current and at arbitrary height)
  * Tendermint block at height
  * Inbound addresses and other chain info
  * Asgard & Yggdrasil vaults (new!)
  * Balance of THOR account



  `python -m pip install git+https://github.com/tirinox/aiothornode`



  The following code is quite self-documenting:

  ```
  import random

  from aiothornode.connector import *
  from aiothornode.env import *
  import asyncio
  import aiohttp


  def delim():
      print('-' * 100)


  async def main():
      env = MAINNET.copy()
      

      async with aiohttp.ClientSession() as session:
          connector = ThorConnector(env, session)

          genesis = await connector.query_genesis()
          print(f'Chain ID = {genesis["chain_id"]}')
          delim()

          chains = await connector.query_chain_info()
          chains = list(chains.values())
          print('Chain info:', chains)
          delim()

          print('Tendermint Block:')
          tender_block = await connector.query_tendermint_block_raw(100001)
          block_header = tender_block['result']['block']['header']
          print(f'{block_header["height"] = } and {block_header["time"] = }')
          delim()

          constants = await connector.query_constants()
          print(f'Constants: {constants}')
          delim()

          mimir = await connector.query_mimir()
          mimir_1 = mimir.get('MINIMUMBONDINRUNE')
          print(f'Mimir: {mimir}, MINIMUMBONDINRUNE = {mimir_1}')
          delim()

          queue = await connector.query_queue()
          print(f'Queue: {queue}')
          delim()

          node_accounts = await connector.query_node_accounts(consensus=False)
          print(f'Example node account: {random.sample(node_accounts, 1)[0]}')
          delim()

          pool = await connector.query_pool('BNB.BUSD-BD1', height=8218339)
          print(pool)
          delim()

          pools = await connector.query_pools()
          print(pools[0])
          print(f'Total {len(pools)} pools')
          delim()

          bank = await connector.query_balance('thor1dheycdevq39qlkxs2a6wuuzyn4aqxhve4qxtxt')
          print(f'Balance of {bank.address} is {bank.runes_float} Rune')
          delim()


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



  Install PyTest and an async plugin for it:

  ```
  pip install pytest
  pip install pytest-asyncio
  ```

  Then run

  ```
  pytest test
  ```


pkgId: ab088fe6b47f9de0110f2874b8d057075a5be325518d4f9e20d948bf57d2337d
name: python-aiothrottler
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: Throttler for asyncio Python
url: https://github.com/michalc/aiothrottler
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiothrottler-0.0.16-1.src.rpm
checksum_type: sha256
description:
  Throttler for asyncio Python




  ```bash
  pip install aiothrottler
  ```




  Create a shared `Throttler`, passing a minimum interval, e.g. `0.5` seconds

  ```python
  from aiothrottler import Throttler

  throttler = Throttler(min_interval=0.5)
  ```

  and then just before the piece(s) of code to be throttled, _call_ this and `await` its result.

  ```python
  await throttler()


  ```




  ```python
  import asyncio
  import time

  from aiothrottler import Throttler

  async def main():
      throttler = Throttler(min_interval=0.5)
      await asyncio.gather(*[
          worker(throttler) for _ in range(10)
      ])

  async def worker(throttler):
      await throttler()
      
      
      print(time.time())

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




  ```python
  import asyncio
  import random
  import time

  from aiothrottler import Throttler

  async def main():
      throttler = Throttler(min_interval=0.5)
      for _ in range(10):
          await throttler()
          
          
          print(time.time())
          await asyncio.sleep(random.random())

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




  - The API features a function to call to `await` its result [some use a context manager]

  - The API is imperative [some use a functional approach/higher-order function]

  - No polling is used [some use polling internally]

  - A _minimum interval between resolutions_ is used to throttle [rather that a _max resolutions per time interval_, which can cause an irregular pattern of resolutions]

  - The tests cover edge cases, such as asserting on throttling after tasks being throttled have been cancelled [some alternatives do not]


pkgId: 6e36ea055948078779d1574872f6b556deb55aa369071cc16ea34f7e0136b390
name: python-aiotica
arch: src
version: 1.0.12
epoch: 0
release: 1
summary: Gateway programming library of KASO AioTica
url: https://pypi.org/project/aiotica/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotica-1.0.12-1.src.rpm
checksum_type: sha256
description:
  ```markdown


  ![License](https://img.shields.io/badge/license-MIT-blue.svg)



  `aiotica` is a gateway programming library designed for the KASO IoT platform. This library provides various modules to handle event reception, access control, sensor data processing, and more, facilitating seamless interaction with IoT devices and services.



  - Event reception and handling
  - IoT access control
  - MQTT messaging support
  - AWS Greengrass integration
  - Sensor data processing
  - API service configuration



  You can install the `aiotica` library using `pip`:

  ```sh
  pip install aiotica
  ```







  ```sh
  python3 -m venv env
  ```



  ```sh
  source env/bin/activate
  ```



  ```sh
  pip install -r requirements.txt
  ```



  ```sh
  python3 -m pip install -U git+https://github.com/aws-greengrass/aws-greengrass-gdk-cli.git@v1.6.2
  ```





  ```sh
  export AWS_IOT_THING_NAME=YOUR_THING_NAME
  export DEV_ACCESS_KEY=YOUR_ACCESS_KEY
  export DEV_SECURITY_KEY=YOUR_SECURITY_KEY
  export APPLICATION_NAME=WORKING_APPLICATION_NAME
  export ENVIRONMENT=Dev
  ```



  ```powershell
  $env:AWS_IOT_THING_NAME = "YOUR_THING_NAME"
  $env:DEV_ACCESS_KEY = "YOUR_AWS_ACCESS_KEY"
  $env:DEV_SECURITY_KEY = "YOUR_AWS_SECURITY_KEY"
  $env:APPLICATION_NAME = "CORRECT_APPLICATOIN_NAME"
  $env:ENVIRONMENT = "Dev"
  ```



  Here's an example of how to import and use the various modules provided by `aiotica`:

  ```python
  from aiotica.event_receiver import EventReceiver
  from aiotica.iot_access_control import IotAccessControl
  from aiotica.model.sensor_value import SensorValue
  from aiotica.platform.greengrass_client import GreengrassClient


  event_receiver = EventReceiver()
  access_control = IotAccessControl()
  sensor_value = SensorValue()
  greengrass_client = GreengrassClient()


  event_receiver.receive_event()
  sensor_data = sensor_value.get_value()
  greengrass_client.connect()
  ```



  The library has the following directory structure:

  ```
  aiotica/
  ├── event_receiver.py
  ├── iot_access_control.py
  ├── model/
  │   ├── error_log.py
  │   ├── iot_credentials.py
  │   ├── log_base.py
  │   ├── mqtt_message.py
  │   ├── sensor_value.py
  │   └── thing_config.py
  ├── platform/
  │   ├── greengrass_client.py
  │   ├── ipc_client.py
  │   ├── mqtt_base_interface.py
  │   └── paho_mqtt_client.py
  ├── service/
  │   ├── api_service.py
  │   └── config.py
  └── setup.py
  ```



  The `aiotica` library requires the following dependencies:

  - `Rx==3.2.0`
  - `paho-mqtt==2.1.0`
  - `boto3==1.34.95`
  - `awsiotsdk==1.21.4`
  - `requests==2.31.0`

  These dependencies are automatically installed when you install the library via `pip`.




  To deploy your Python library to Test PyPI, follow these steps:



  Ensure you have `setuptools`, `wheel`, and `twine` installed. You can install them using pip:

  ```bash
  pip install setuptools wheel twine
  ```



  Create the distribution packages for your library. This includes the source distribution (`.tar.gz`) and the built distribution (`.whl`).

  In the directory containing your `setup.py` file, run:

  ```bash
  python setup.py sdist bdist_wheel
  ```

  This command will generate the distribution files in a `dist/` directory.



  Use `twine` to upload these files to Test PyPI. Use the API token you obtained from Test PyPI.

  ```bash
  twine upload dist/* -u __token__ -p <your-api-token>
  ```

  Replace `<your-api-token>` with your actual API token from Test PyPI.



  If you prefer to use an API command for publishing, you can use `curl` to upload your files. Here’s an example command:



  Make sure to replace `yourpackage-0.0.1-py3-none-any.whl` and `yourpackage-0.0.1.tar.gz` with the actual filenames of your distribution files, and `<your-api-token>` with your API token.



  1. **Install required libraries:**

      ```bash
      pip install setuptools wheel twine
      ```

  2. **Create distribution files:**

      ```bash
      python setup.py sdist bdist_wheel
      ```

  3. **Upload to Test PyPI using twine:**

      ```bash
      twine upload --repository-url https://test.pypi.org/legacy/ dist/* -u __token__ -p <your-api-token>
      ```

      Or, **upload using curl:**

      ```bash
      curl -F "content=@dist/yourpackage-0.0.1-py3-none-any.whl" -F "content=@dist/yourpackage-0.0.1.tar.gz" -u __token__:<your-api-token> https://test.pypi.org/legacy/
      ```



  This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.



  Contributions are welcome! Please open an issue or submit a pull request for any improvements or bug fixes.



  KASO

  For any queries or further information, you can reach out to [author's email] (you@example.com).



  - Thanks to the developers of the dependencies used in this project.
  - Special thanks to the KASO team for their continuous support.
  ```

  Feel free to replace placeholders like `YOUR_THING_NAME`, `YOUR_ACCESS_KEY`, `YOUR_SECURITY_KEY`, `WORKING_APPLICATION_NAME`, and `you@example.com` with actual values or instructions.


pkgId: 8511db3992aa18b95d7ee0f3c29b769a104774889a71f8e2429dde721364f6c4
name: python-aiotiktok
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Tool for parse tiktok data
url: https://github.com/sheldygg/aiotiktok
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotiktok-3.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPi Package Version](https://img.shields.io/pypi/v/aiotiktok?color=blue)](https://pypi.python.org/pypi/aiotiktok)
  [![Downloads](https://img.shields.io/pypi/dm/aiotiktok?color=blue)](https://pypi.python.org/pypi/aiotiktok)

  **aiotiktok** is a super simple and fast library for retrieving all video data from TikTok.



  ```python
  import asyncio

  from aiotiktok.client import TikTokClient


  async def main():
      client = TikTokClient()

      await client.get_video_data(video_id="7349190849017744646")

      await client.close()


  asyncio.run(main())

  ```


pkgId: 39e9e8e5b0a5019d1c81936daf507dd849e5d9818bfbc51efd3601041a19fad0
name: python-aiotinydb
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: asyncio compatibility shim for tinydb
url: https://pypi.org/project/aiotinydb/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotinydb-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/aiotinydb.svg)](https://pypi.python.org/pypi/aiotinydb) [![PyPI](https://img.shields.io/pypi/pyversions/aiotinydb.svg)](https://pypi.python.org/pypi/aiotinydb) [![PyPI](https://img.shields.io/pypi/l/aiotinydb.svg)](https://pypi.python.org/pypi/aiotinydb) ![Build Status](https://github.com/aiotinydb/aiotinydb/actions/workflows/ci.yml/badge.svg) [![Say Thanks!](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/ASMfreaK)

  asyncio compatibility shim for [`TinyDB`](https://github.com/msiemens/tinydb)

  Enables usage of TinyDB in asyncio-aware contexts without slow syncronous IO.


  See documentation on compatible version of [`TinyDB`](https://tinydb.readthedocs.io/en/v4.7.0/).

  Basically all API calls from `TinyDB` are supported in `AIOTinyDB`. With the following exceptions: you **should not** use basic `with` syntax and `close` functions. Instead, you **should** use `async with`.

  ```python
  import asyncio
  from aiotinydb import AIOTinyDB

  async def test():
      async with AIOTinyDB('test.json') as db:
          db.insert(dict(counter=1))

  loop = asyncio.new_event_loop()
  loop.run_until_complete(test())
  loop.close()
  ```

  CPU-bound operations like `db.search()`, `db.update()` etc. are executed synchronously and may block the event loop under heavy load. Use multiprocessing if that's an issue (see [#6](https://github.com/aiotinydb/aiotinydb/issues/6#issuecomment-1125343152) and [examples/processpool.py](examples/processpool.py) for an example).



  Any middlewares you use **should be** async-aware. See example:

  ```python
  from tinydb.middlewares import CachingMiddleware as VanillaCachingMiddleware
  from aiotinydb.middleware import AIOMiddleware

  class CachingMiddleware(VanillaCachingMiddleware, AIOMiddlewareMixin):
      """
          Async-aware CachingMiddleware. For more info read
          docstring for `tinydb.middlewares.CachingMiddleware`
      """
      pass
  ```

  If middleware requires some special handling on entry and exit, override `__aenter__` and `__aexit__`.



  Instances of `AIOTinyDB` support database access from multiple coroutines.

  On **unix-like systems**, it's also possible to access one database concurrently from multiple processes when using `AIOJSONStorage` (the default) or `AIOImmutableJSONStorage`.



  ```
  pip install aiotinydb
  ```


pkgId: 021b1def8ed0b4b651540be515822ea5a3be1f85cfa744cfa994852b86b0c2bd
name: python-aiotractive
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Asynchronous Python client for the Tractive REST API
url: https://github.com/zhulik/aiotractive
rpm_license: The MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotractive-0.6.0-1.src.rpm
checksum_type: sha256
description:
  ![Continuous Integration](https://github.com/zhulik/aiotractive/workflows/Continuous%20Integration/badge.svg?branch=main)

  **Unofficial** Asynchronous Python client for the [Tractive](https://tractive.com) REST API.

  **This project and it's author are not affilated with Tractive GmbH**

  This project is a result of reverse engineering of the Tractive web app.

  Inspired by [home_assistant_tractive](https://github.com/Danielhiversen/home_assistant_tractive).

  Initially some code was borrowed from home_assistant_tractive, but in the end all of it was replaced with my own implementations.

  The package is in active development. **Not all features available in the Tractive web app are implemented.**

  Important notes:

  - In order to use Tractive devices and their service you need to have an active subscription.
  - Tractive may change their API at any point of time and this project will be broken. Please, report any issues.



  `pip install aiotractive`



  ```python
  import asyncio

  from aiotractive import Tractive

  async def main():
    async with Tractive("email", "password") as client:
      
      pass

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




  Tractive is the entrypoint class, it acts as an async context manager and provides access to API endpoints.



  ```python
  client.authenticate()


  ```



  ```python
  trackers = await client.trackers()
  tracker = trackers[0]



  tracker = client.tracker("TRACKER_ID")


  await trackers.details() # Includes device capabilities, battery status(not level), charging state and so on

  await tracker.hw_info() # Includes battery level, firmware version, model and so on


  await tracker.pos_report() # Includes coordinates, latitude, speed and so on



  ```python
  now = datetime.timestamp(datetime.now())
  time_from = now - 3600 * LAST_HOURS
  time_to = now
  format = json_segments
  await tracker.positions(time_from, time_to, format):
  ```


  await set_buzzer_active(True) # or False


  await set_led_active(True) # or False


  await set_live_tracking_active(True) # or False
  ```


  ```python
  objects = await client.trackable_objects()

  object = objects[0]


  await object.details() # Includes pet's name, pet's tracker id and so on
  ```



  ```python
  async for event in client.events():
      pp(event)

  ```

  After connecting you will immediately receive one `tracker_status` event per owned tracker.
  The first event always includes full current status of the tracker including current position, battery level, states of the buzzer,
  the LED and the live tracking.

  All following events will have the same name, but only include one of these: either a position, battery info, or a buzzer/LED/live
  status.


  You know;)


pkgId: ca8663606e8adb172f474eb0b4670de63fb89449e2479eb698fd96e2c293bac5
name: python-aiotrello
arch: src
version: 0.0.7.7
epoch: 0
release: 1
summary: Async Trello library
url: https://github.com/zomien/aiotrello
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotrello-0.0.7.7-1.src.rpm
checksum_type: sha256
description:
  Async Trello Python library


  Install with [pip](https://pypi.org/project/pip/)

  ```sh
  $ pip install aiotrello
  ```



  ```py
  import asyncio; loop = asyncio.get_event_loop()
  from aiotrello import Trello

  trello = Trello(key="123", token="abc123") # Initialize a new Trello client


  async def main():
  	
  	for i in range(10):
  		board = await trello.create_board(f"Board {i}")
  		await board.create_list("My List")

  	
  	for board in await trello.get_boards():
  		if board.name.startswith("Board"):
  			await board.delete()

  	
  	my_board = await trello.get_board(lambda b: b.id == "123")
  	my_list = await my_board.get_list(lambda l: l.name == "My List")
  	card = await my_list.create_card("Hello World", "Here is my awesome card")
  	await card.add_comment("aiotrello rocks!")

  	
  	my_other_list = await my_board.get_list(lambda l: l.name == "My Other List")
  	await card.move_to(my_other_list)
  	
  	board2 = await trello.get_board(lambda b: b.name == "My Other Board")
  	list2 = await board2.get_list(lambda l: l.name == "My Other List")
  	await card.move_to(list2, board2)

  	
  	await card.edit(name="This card will be deleted soon..")
  	await card.archive()
  	await card.delete()


  try:
  	loop.run_until_complete(main())
  finally:
  	loop.run_until_complete(trello.session.close()) # Remember to close the session!


  ```



  Join our [Discord Server](https://discord.gg/hK9DpQQ)


pkgId: f4ff7b10af926dc6e34e177a23b35b061f6ebe11ccbdc0f89ec2e852b6f34442
name: python-aiotrino
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: ASyncIO Client for the Trino distributed SQL Engine
url: https://github.com/mvanderlee/aiotrino/tree/main
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotrino-0.2.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/mvanderlee/aiotrino/workflows/ci/badge.svg)](https://github.com/mvanderlee/aiotrino/actions?query=workflow%3Aci+event%3Apush+branch%3Apy3-async)
  [![Trino Slack](https://img.shields.io/static/v1?logo=slack&logoColor=959DA5&label=Slack&labelColor=333a41&message=join%20conversation&color=3AC358)](https://trino.io/slack.html)
  [![Trino: The Definitive Guide book download](https://img.shields.io/badge/Trino%3A%20The%20Definitive%20Guide-download-brightgreen)](https://www.starburst.io/info/oreilly-trino-guide/)



  This package provides a asyncio client interface to query [Trino](https://trino.io/)
  a distributed SQL engine. It supports Python 3.7, 3.8, 3.9, 3.10, 3.11, 3.12.


  ```
  $ pip install aiotrino
  ```



  Use the DBAPI interface to query Trino:

  ```python
  import aiotrino
  conn = aiotrino.dbapi.connect(
      host='localhost',
      port=8080,
      user='the-user',
      catalog='the-catalog',
      schema='the-schema',
  )
  cur = await conn.cursor()
  await cur.execute('SELECT * FROM system.runtime.nodes')
  rows = await cur.fetchall()
  await conn.close()
  ```
  Or with context manager
  ```python
  import aiotrino
  async with aiotrino.dbapi.connect(
      host='localhost',
      port=8080,
      user='the-user',
      catalog='the-catalog',
      schema='the-schema',
  ) as conn:
      cur = await conn.cursor()
      await cur.execute('SELECT * FROM system.runtime.nodes')
      rows = await cur.fetchall()
  ```

  This will query the `system.runtime.nodes` system tables that shows the nodes
  in the Trino cluster.

  The DBAPI implementation in `aiotrino.dbapi` provides methods to retrieve fewer
  rows for example `Cursorfetchone()` or `Cursor.fetchmany()`. By default
  `Cursor.fetchmany()` fetches one row. Please set
  `trino.dbapi.Cursor.arraysize` accordingly.

  For backwards compatibility with PrestoSQL, override the headers at the start of your application
  ```python
  import aiotrino
  aiotrino.constants.HEADERS = aiotrino.constants.PrestoHeaders
  ```


  The `BasicAuthentication` class can be used to connect to a LDAP-configured Trino
  cluster:
  ```python
  import aiotrino
  conn = aiotrino.dbapi.connect(
      host='coordinator url',
      port=8443,
      user='the-user',
      catalog='the-catalog',
      schema='the-schema',
      http_scheme='https',
      auth=aiotrino.auth.BasicAuthentication("principal id", "password"),
  )
  cur = await conn.cursor()
  await cur.execute('SELECT * FROM system.runtime.nodes')
  rows = await cur.fetchall()
  await conn.close()
  ```


  The `JWTAuthentication` class can be used to connect to a configured Trino cluster:
  ```python
  import aiotrino
  conn = aiotrino.dbapi.connect(
      host='coordinator url',
      port=8443,
      catalog='the-catalog',
      schema='the-schema',
      http_scheme='https',
      auth=aiotrino.auth.JWTAuthentication(token="jwt-token"),
  )
  cur = await conn.cursor()
  await cur.execute('SELECT * FROM system.runtime.nodes')
  rows = await cur.fetchall()
  await conn.close()
  ```


  The client runs by default in *autocommit* mode. To enable transactions, set
  *isolation_level* to a value different than `IsolationLevel.AUTOCOMMIT`:

  ```python
  import aiotrino
  from aiotrino import transaction
  async with aiotrino.dbapi.connect(
      host='localhost',
      port=8080,
      user='the-user',
      catalog='the-catalog',
      schema='the-schema',
      isolation_level=transaction.IsolationLevel.REPEATABLE_READ,
  ) as conn:
    cur = await conn.cursor()
    await cur.execute('INSERT INTO sometable VALUES (1, 2, 3)')
    await cur.fetchone()
    await cur.execute('INSERT INTO sometable VALUES (4, 5, 6)')
    await cur.fetchone()
  ```

  The transaction is created when the first SQL statement is executed.
  `trino.dbapi.Connection.commit()` will be automatically called when the code
  exits the *with* context and the queries succeed, otherwise
  `trino.dbapi.Connection.rollback()' will be called.





  Start by forking the repository and then modify the code in your fork.

  Clone the repository and go inside the code directory. Then you can get the
  version with `./setup.py --version`.

  We recommend that you use `virtualenv` for development:

  ```
  $ virtualenv .venv
  $ . .venv/bin/activate

  $ pip install .
  ```

  For development purpose, pip can reference the code you are modifying in a
  *virtualenv*:

  ```
  $ pip install -e .[tests]
  ```

  That way, you do not need to run `pip install` again to make your changes
  applied to the *virtualenv*.

  When the code is ready, submit a Pull Request.



  - For Python code, adhere to PEP 8.
  - Prefer code that is readable over one that is "clever".
  - When writing a Git commit message, follow these [guidelines](https://chris.beams.io/posts/git-commit/).



  There is a helper scripts, `run`, that provides commands to run tests.
  Type `./run tests` to run both unit and integration tests.

  `aiotrino` uses [pytest](https://pytest.org/) for its tests. To run
  only unit tests, type:

  ```
  $ pytest tests
  ```

  Then you can pass options like `--pdb` or anything supported by `pytest --help`.

  To run the tests with different versions of Python in managed *virtualenvs*,
  use `tox` (see the configuration in `tox.ini`):

  ```
  $ tox
  ```

  To run integration tests:

  ```
  $ pytest integration_tests
  ```

  They pull a Docker image and then run a container with a Trino server:
  - the image is named `trinodb/trino:${TRINO_VERSION}`
  - the container is named `aiotrino-python-client-tests-{uuid4()[:7]}`




  Supported OS Ubuntu 22.04

  1. Install [pyenv](https://github.com/pyenv/pyenv#automatic-installer)

      ```shell
      curl https://pyenv.run | bash
      ```

  2. Install required python versions

      ```shell
      
      pyenv install 3.7, 3.8, 3.9, 3.10, 3.11, 3.12
      ```

  3. Set the installed versions as default for the shell. This allows `tox` to find them.

      List installed versions and update the following command as needed.
      ```shell
      pyenv versions
      ```

      ```shell
      pyenv shell 3.12.1 3.11.3 3.10.11 3.9.16 3.8.16 3.7.16
      ```

  4. Install `tox`

      ```shell
      pip install tox
      ```

  5. Run `tox`

      ```shell
      tox
      ```



  - [Set up your development environment](#Getting-Started-With-Development).
  - Change version in `aiotrino/__init__.py`.
  - Commit and create an annotated tag (`git tag -m '' current_version`)
  - Run the following:
    ```bash
    . .venv/bin/activate &&
    pip install twine wheel setuptools &&
    rm -rf dist/ &&
    ./setup.py sdist bdist_wheel &&
    twine upload dist/* &&
    open https://pypi.org/project/aiotrino/ &&
    echo "Released!"
    ```
  - Push the branch and the tag (`git push upstream master current_version`)
  - Send release announcement.



  Feel free to create an issue as it make your request visible to other users and contributors.

  If an interactive discussion would be better or if you just want to hangout and chat about
  the Trino Python client, you can join us on the *#python-client* channel on
  [Trino Slack](https://trino.io/slack.html).


pkgId: d14538c966dbb071b6a0b7f551cbf0e883fce26027408cda8face48325db292a
name: python-aiotruenas-client
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: A Python client library for the TrueNAS API
url: https://pypi.org/project/aiotruenas-client/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotruenas-client-0.10.0-1.src.rpm
checksum_type: sha256
description:
  ![Lint](https://github.com/sdwilsh/aiotruenas-client/workflows/Lint/badge.svg)
  ![Build](https://github.com/sdwilsh/aiotruenas-client/workflows/Build/badge.svg)



  This python module utilizes the [TrueNAS Websocket API](https://www.truenas.com/docs/hub/additional-topics/api/websocket_api.html) to get state from a TrueNAS instance.



  ```
  pip install aiotruenas-client
  ```



  ```python
  from aiotruenas_client import CachingMachine as TrueNASMachine

  machine = await TrueNASMachine.create(
      "hostname.of.machine",
      api_key="someapikey"
  )
  datasets = await machine.get_datasets()
  disks = await machine.get_disks()
  jails = await machine.get_jails()
  pools = await machine.get_pools()
  vms = await machine.get_vms()
  ```

  Alternatively, a username and password may also be supplied.



  Object representing a TrueNAS instance.



  Available from `machine.datasets`, contains information about the datasets on the pools on the machine.



  Available from `machine.disks`, contains information about the disks attached to the machine.



  Available from `machine.jails`, contains information about the jails available on the machine.



  Available from `machine.pools`, contains information about the ZFS pools known to the machine.



  Available from `machine.vms`, contains information about the virtural machines available on the machine.

  Each instance has the following methods availabe:

  - `vm.start`
  - `vm.stop`
  - `vm.restart`





  ```
  python3.8 -m venv .venv
  source .venv/bin/activate


  pip install -r requirements.txt


  pip install -r requirements-dev.txt


  pre-commit install
  ```



  When adding support for a new object, or updating existing code, it can be useful to see the raw response from the
  TrueNAS machine from time to time. In order to help do that easily, you can drop a `.auth.yaml` file in the root of
  the repository, with the following content:

  ```yaml
  host: "some.host.name"
  api_key: "someapikey"
  ```

  Use `scripts/invoke_method.py` to call a method:

  ```
  python scripts/invoke_method.py disk.query
  ```

  Use `scripts/subscribe.py` to subscribe to a topic:

  ```
  python scripts/subscribe.py reporting.realtime
  ```

  Run either with -h to see additional options.



  Tests are run with `pytest`.


pkgId: 7d03d65408efa26656f11ee73d0fd74034504dfb19ec57a54b39012a1a23cedd
name: python-aiotsmart
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Asynchronous Python client for TSmart.
url: https://github.com/andrew-codechimp/python-tsmart
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotsmart-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Release][releases-shield]][releases]
  [![Python Versions][python-versions-shield]][pypi]
  ![Project Stage][project-stage-shield]
  ![Project Maintenance][maintenance-shield]
  [![License][license-shield]](LICENSE.md)

  [![Build Status][build-shield]][build]
  [![Code Coverage][codecov-shield]][codecov]
  [![Code Smells][code-smells]][sonarcloud]

  Asynchronous Python client for TSmart.



  This package allows you to fetch data from your TSmart Immersion Heater.



  ```bash
  pip install aiotsmart
  ```


  ```python
  from aiotsmart.tsmart import TSmartClient, TSmartDiscovery, Mode


  discovery = TSmartDiscovery()
  devices = await discovery.discover()
  print(devices)


  client = TSmartClient(YOUR_IP)
  configuration = await client.configuration_read()
  print(configuration)


  client = TSmartClient(YOUR_IP)
  status = await client.control_read()
  print(status)


  client = TSmartClient(YOUR_IP)
  await client.control_write(power=True, mode=Mode.MANUAL, setpoint=30)
  ```



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

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

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



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

  We've set up a separate document for our
  [contribution guidelines](.github/CONTRIBUTING.md).

  Thank you for being involved! :heart_eyes:



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

  You need at least:

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

  To install all packages, including all development requirements:

  ```bash
  npm install
  poetry install
  ```

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

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

  To run just the Python tests:

  ```bash
  poetry run pytest
  ```



  The content is by [Andrew Jackson][andrew-codechimp].

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



  This library is in no way approved, endorsed or supported by Tesla UK Ltd.



  <details>
      <summary>This library builds upon the great work by Paul Warren</summary>
      MIT License

      Copyright (c) 2023 Paul Warren

      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.
  </details>




  MIT License

  Copyright (c) 2024 Andrew Jackson

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

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

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

  [build-shield]: https://github.com/andrew-codechimp/python-tsmart/actions/workflows/tests.yaml/badge.svg
  [build]: https://github.com/andrew-codechimp/python-tsmart/actions
  [code-smells]: https://sonarcloud.io/api/project_badges/measure?project=andrew-codechimp_python-tsmart&metric=code_smells
  [codecov-shield]: https://codecov.io/gh/andrew-codechimp/python-tsmart/branch/main/graph/badge.svg
  [codecov]: https://codecov.io/gh/andrew-codechimp/python-tsmart
  [commits-shield]: https://img.shields.io/github/commit-activity/y/andrew-codechimp/python-tsmart.svg
  [commits]: https://github.com/andrew-codechimp/python-tsmart/commits/master
  [contributors]: https://github.com/andrew-codechimp/python-tsmart/graphs/contributors
  [andrew-codechimp]: https://github.com/andrew-codechimp
  [keepchangelog]: http://keepachangelog.com/en/1.0.0/
  [license-shield]: https://img.shields.io/github/license/andrew-codechimp/python-tsmart.svg
  [maintenance-shield]: https://img.shields.io/maintenance/yes/2024.svg
  [poetry-install]: https://python-poetry.org/docs/#installation
  [poetry]: https://python-poetry.org
  [pre-commit]: https://pre-commit.com/
  [project-stage-shield]: https://img.shields.io/badge/project%20stage-stable-green.svg
  [python-versions-shield]: https://img.shields.io/pypi/pyversions/aiotsmart
  [releases-shield]: https://img.shields.io/github/release/andrew-codechimp/python-tsmart.svg
  [releases]: https://github.com/andrew-codechimp/python-tsmart/releases
  [semver]: http://semver.org/spec/v2.0.0.html
  [sonarcloud]: https://sonarcloud.io/summary/new_code?id=andrew-codechimp_python-tsmart
  [pypi]: https://pypi.org/project/aiotsmart/


pkgId: 79570058d235a62b243d2fcc2a1d7ffc3b3948a645f63ce2539c89c17480a701
name: python-aiotube
arch: src
version: 1.7.2
epoch: 0
release: 1
summary: Access YouTube Public Data without YouTube API
url: https://github.com/jnsougata/aiotube
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotube-1.7.2-1.src.rpm
checksum_type: sha256
description:
  A library to access YouTube Public Data without YouTubeAPI
  - `Discord <https://discord.gg/YAFGAaMrTC>`_
  - `GitHub <https://github.com/jnsougata/AioTube>`_
  - `REST API (BETA) <https://aiotube.deta.dev/>`_


pkgId: c6113642e5dee803619c3f2d126c0441e66fb2f23a2d5211fca0255e7d88a858
name: python-aiotus
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Asynchronous tus (tus.io) client library
url: https://github.com/JenSte/aiotus
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotus-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">aiotus - Asynchronous tus client library</h1>

  <div align="center">
    <a href="https://opensource.org/licenses/Apache-2.0">
      <img alt="License: Apache 2.0" src="https://img.shields.io/badge/license-Apache%202.0-blue.svg?style=flat-square">
    </a>
    <a href="https://www.python.org">
      <img alt="Python Versions" src="https://img.shields.io/pypi/pyversions/aiotus?style=flat-square">
    </a>
    <a href="http://mypy-lang.org">
      <img alt="Mypy Checked" src="https://img.shields.io/badge/mypy-checked-blue.svg?style=flat-square">
    </a>
    <a href="https://black.readthedocs.io">
      <img alt="Code Style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square">
    </a>
  </div>
  <div align="center">
    <a href="https://github.com/JenSte/aiotus/actions">
      <img alt="CI Status" src="https://img.shields.io/github/actions/workflow/status/JenSte/aiotus/ci.yml?branch=master&style=flat-square">
    </a>
    <a href="https://codecov.io/gh/JenSte/aiotus">
      <img alt="Code Coverage" src="https://img.shields.io/codecov/c/github/JenSte/aiotus?style=flat-square">
    </a>
    <a href="https://sonarcloud.io/dashboard?id=JenSte_aiotus">
      <img alt="Quality Gate" src="https://img.shields.io/sonar/quality_gate/JenSte_aiotus?server=https%3A%2F%2Fsonarcloud.io&style=flat-square">
    </a>
    <a href="https://aiotus.readthedocs.io/en/latest">
      <img alt="Documentation Status" src="https://img.shields.io/readthedocs/aiotus?style=flat-square">
    </a>
    <a href="https://pypi.org/project/aiotus">
      <img alt="PyPI Package Version" src="https://img.shields.io/pypi/v/aiotus?style=flat-square">
    </a>
  </div>

  ``aiotus`` implements the client-side of the [tus](https://tus.io) protocol.



  * Implements the [core protocol](https://tus.io/protocols/resumable-upload.html#core-protocol) as
    well as the [creation](https://tus.io/protocols/resumable-upload.html#creation)
    and [concatenation](https://tus.io/protocols/resumable-upload.html#concatenation) extensions.
  * Built-in retry support in case of communication errors.
  * Extensive test bench, including tests against the reference [tusd](https://github.com/tus/tusd) server.



  ```python
  import aiotus

  creation_url = "http://example.com/files"

  metadata = {
      "Filename": "image.jpeg".encode(),
      "Content-Type": "image/jpeg".encode()
  }


  with open("image.jpeg", "rb") as f:
      location = await aiotus.upload(creation_url, f, metadata)
      


  metadata = await aiotus.metadata(location)
  ```



  * [Python](https://www.python.org) ≥ 3.9
  * [aiohttp](https://pypi.org/project/aiohttp)
  * [tenacity](https://pypi.org/project/tenacity)



  Install ``aiotus`` from [PyPi](https://pypi.org/project/aiotus):

  ```
  pip install aiotus
  ```

  Development versions can be installed from [TestPyPi](https://test.pypi.org/project/aiotus):

  ```
  pip install --index-url https://test.pypi.org/simple --extra-index-url https://pypi.org/simple aiotus
  ```



  The documentation can be found at [aiotus.readthedocs.io](https://aiotus.readthedocs.io/en/latest).




  ``aiotus`` is licensed under the Apache 2.0 license.


pkgId: 31a47481316d123dfa0dced2896feb3e80338227851715717cf0515ce92917ff
name: python-aiotusclient
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: tus.io-compatible upload client library for Python asyncio
url: https://github.com/lablup/aiotusclient
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotusclient-0.1.4-1.src.rpm
checksum_type: sha256
description:
  aiotusclient is a fork of tus-py-client rewritten for Python asyncio and aiohttp.
  It is used to communicate with storage proxies that handle large transfers for vfolder uploads and downloads.



  * `aiotusclient`
    - `client`: The client instance class which communicates between Backend.AI Manager
    - `baseuploader` and `uploader`
      - Responsible for chunking the file and asynchronously uploading to tus server
    - `request`
      - Handles the uploading request





  * Python 3.7 or higher with [pyenv](https://github.com/pyenv/pyenv)
  and [pyenv-virtualenv](https://github.com/pyenv/pyenv-virtualenv) (optional but recommneded)



  First, prepare the source clone of this agent:
  ```console

  ```

  From now on, let's assume all shell commands are executed inside the virtualenv. And we located in backend.ai root directory.

  Now install dependencies:
  ```console

  ```


  When done, import into your code the aiotusclient
  ```python
  from aiotusclient import client

  tus_client = client.TusClient(session_create_url, session_upload_url, rqst.headers, params)
  ```


  This library was forked from [tus-py-client](https://github.com/tus/tus-py-client) and customized in order to facilitate asynchronous communication with our TUS server.


pkgId: 02c53fe24b708fa73258347a9a3c0f971f1838323188b516ad2c9ef7ca2f63fe
name: python-aiotx
arch: src
version: 4.10.0
epoch: 0
release: 1
summary: An asynchronous library for interacting with various cryptocurrencies and blockchains
url: https://github.com/Grommash9/aiotx
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiotx-4.10.0-1.src.rpm
checksum_type: sha256
description:
  1. **EVM Client:** AioTx offers an EVM client that supports popular EVM-based networks such as Ethereum, Binance Smart Chain, Polygon, Avalanche, Fantom, Cronos, and more. With the EVM client, you can easily generate addresses, retrieve balances, send transactions, interact with smart contracts, and perform various other operations.
  2. **UTXO Client:** For UTXO-based networks like Bitcoin and Litecoin, AioTx provides a UTXO client. This client allows you to generate addresses, import addresses for monitoring, retrieve balances, estimate fees, and send transactions effortlessly. The UTXO client also includes support for bulk transactions, enabling you to send multiple transactions in a single operation.
  3. **TON Client:** Client for Telegram Open Network - now we have monitoring and token sending TON and bulk send, also sending jettons and checking jetton balance
  4. **TRON Client:** Client for TRON (trx) blockchain - you can monitor transaction and do TRX/TRC20 transactions
  5. **Blockchain Monitoring:** One of the standout features of AioTx is its blockchain monitoring capabilities. You can easily monitor new blocks and transactions on the supported blockchains by registering custom handlers. AioTx provides a simple and intuitive way to start and stop monitoring, and it even allows you to monitor multiple clients simultaneously. Integration with the Aiogram library is also supported, enabling you to send notifications or perform actions based on the received blocks and transactions.
  6. **Database Storage:** AioTx includes built-in support for database storage, allowing you to store transaction and UTXO data for efficient monitoring and management. You have the flexibility to choose between SQLite and MySQL as the database backend, both of which have been thoroughly tested and are known to work seamlessly with AioTx.
  7. **Testing:** To ensure the reliability and stability of AioTx, the package is extensively covered by tests. The test suite includes comprehensive test cases for various scenarios, networks, and operations. AioTx utilizes the VCR (Video Cassette Recorder) library to record and replay network interactions, making the tests deterministic and independent of external services.


pkgId: f20db55848484aeb18a092baa317909a3ab5fa744ebb3375f479c18daefc906e
name: python-aioudp
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A better API for asynchronous UDP
url: https://github.com/ThatXliner/aioudp
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioudp-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
  [![codecov](https://codecov.io/gh/ThatXliner/aioudp/branch/main/graph/badge.svg)](https://codecov.io/gh/ThatXliner/aioudp)

  [![Documentation Status](https://readthedocs.org/projects/aioudp/badge/?version=latest)](https://aioudp.readthedocs.io/en/latest/?badge=latest)
  [![CI](https://github.com/ThatXliner/aioudp/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/ThatXliner/aioudp/actions/workflows/ci.yml)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aioudp)](https://pypi.org/project/aioudp)
  [![PyPI](https://img.shields.io/pypi/v/aioudp)](https://pypi.org/project/aioudp)
  [![PyPI - License](https://img.shields.io/pypi/l/aioudp)](#license)

  > A better API for asynchronous UDP

  A [websockets](https://websockets.readthedocs.io/en/stable/index.html)-like API for [UDP](https://en.wikipedia.org/wiki/User_Datagram_Protocol)

  Here's an example echo server:

  ```py
  import asyncio
  import signal

  import aioudp


  async def main():
      async def handler(connection):
          async for message in connection:
              await connection.send(message)

      
      
      loop = asyncio.get_running_loop()
      stop = loop.create_future()
      loop.add_signal_handler(signal.SIGTERM, stop.set_result, None)
      loop.add_signal_handler(signal.SIGINT, stop.set_result, None)

      
      async with aioudp.serve("localhost", 9999, handler):
          await stop  # Serve forever

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

  And a client to connect to the server:

  ```py
  import asyncio

  import aioudp


  async def main():
      async with aioudp.connect("localhost", 9999) as connection:
          await connection.send(b"Hello world!")
          assert await connection.recv() == b"Hello world!"

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



  You can get this project via `pip`

  ```bash
  $ pip install aioudp
  ```


  Or, if you're using [Poetry](https://python-poetry.org)

  ```bash
  $ poetry add aioudp
  ```

  > [!NOTE]
  > This library provides no other abstractions over the existing UDP interface in `asyncio` other than the `async`/`await`-based API. This means there is no implicit protocol handled in this library such as [QUIC](https://en.wikipedia.org/wiki/QUIC). You must write your own, or find another library.



  - [AnyIO](https://anyio.readthedocs.io/en/stable/index.html), a broader asynchronous networking and concurrency library for abstracting over any `async` IO implementation. It has a [similar API](https://anyio.readthedocs.io/en/stable/networking.html#working-with-udp-sockets) (which I didn't know about before I wrote this library)
  - [WebSockets](https://websockets.readthedocs.io/en/stable/), a library for Python to interact with WebSockets. Its API heavily inspired the design of AioUDP.
  - [QUIC](https://en.wikipedia.org/wiki/QUIC), a faster protocol similar to TCP, built on UDP.
  - [AioQUIC](https://github.com/aiortc/aioquic), a Python implementation of QUIC.



  Copyright © 2021, Bryan Hu

  This project is licensed under the [GNU GPL v3+](https://github.com/ThatXliner/aioudp/blob/main/LICENSE.txt).

  In short, this means you can do anything with it (distribute, modify, sell) but if you were to publish your changes, you must make the source code and build instructions readily available.

  If you are a company using this project and want an exception, email me at [thatxliner@gmail.com](mailto:thatxliner@gmail.com) and we can discuss.


pkgId: fd89caabd6fd87e1481e8e0be162361654fc8a676c9008b4bf8b4e072dc34334
name: python-aiounfurl
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Making site preview
url: https://github.com/tigorc/aiounfurl
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiounfurl-0.2.4-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/TigorC/aiounfurl.svg?branch=master)](https://travis-ci.org/TigorC/aiounfurl)
  [![Coverage Status](https://coveralls.io/repos/github/TigorC/aiounfurl/badge.svg?branch=master)](https://coveralls.io/github/TigorC/aiounfurl?branch=master)


  Using this library you can extract meta information from web pages and create site preview.
  The library uses four sources of information:

  1. [oEmbed](http://oembed.com)
  2. [Open Graph](http://ogp.me)
  3. [Twitter Cards](https://dev.twitter.com/cards/overview)
  4. HTML meta tags


  * python 3.5
  * aiohttp
  * beautifulsoup4
  * html5lib


  ```bash
  pip install aiounfurl
  ```



  To extract all site data:

  ```python
  import asyncio
  import aiohttp
  from pprint import pprint
  from aiounfurl.views import get_preview_data, fetch_all


  async def get_links_data(links, loop):
      results = []
      async with aiohttp.ClientSession() as session:
          tasks = [fetch_all(session, l, loop) for l in links]
          results = await asyncio.gather(*tasks, loop=loop, return_exceptions=True)
      return [{'link':l, 'data': d} for l, d in zip(links, results)]


  links = [
      'https://habrahabr.ru/post/314606/',
      'https://www.youtube.com/watch?v=9EftQMnuhvU',
      'https://medium.freecodecamp.com/million-requests-per-second-with-python-95c137af319'
  ]
  loop = asyncio.get_event_loop()
  result = loop.run_until_complete(get_links_data(links, loop))
  loop.close()
  pprint(result)
  ```


  Full example you can find [here](https://github.com/TigorC/aiounfurl/blob/master/example/srv.py).

  Install required packages for running example:

  ```bash
  pip install -r example/requirements.txt
  ```
  Run `python srv.py runserver`, then open http://127.0.0.1:8080/



  I added a docker image with the example in http://hub.docker.com/ to run the sample as a separate independent service.

  Running in the background:

  ```bash
  docker run --name aiounfurl -p 8080:8080 -d tigorc/aiounfurl
  ```

  then you can open our example [http://127.0.0.1:8080/](http://127.0.0.1:8080/).

  Using the list of oEmbed providers (a json file with a list of providers /path_to_file/providers.json has to be preliminarily created):

  ```bash
  docker run --name aiounfurl -p 8080:8080 -e "OEMBED_PROVIDERS_FILE=/srv/app/providers.json" -v /path_to_file/providers.json:/srv/app/providers.json -d tigorc/aiounfurl
  ```


  Install the `tox` package and run command:

  ```bash
  tox
  ```


pkgId: 31e017097c87760e249e1add94c0be4c2eb46efbb5ef5c962f0ee2be005cd385
name: python-aioupnp
arch: src
version: 0.0.18
epoch: 0
release: 1
summary: UPnP for asyncio
url: https://github.com/lbryio/aioupnp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioupnp-0.0.18-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/lbryio/aioupnp/workflows/CI/badge.svg)
  [![codecov](https://codecov.io/gh/lbryio/aioupnp/branch/master/graph/badge.svg)](https://codecov.io/gh/lbryio/aioupnp)
  [![PyPI version](https://badge.fury.io/py/aioupnp.svg)](https://badge.fury.io/py/aioupnp)
  [![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/)
  [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/)
  [![Python 3.8](https://img.shields.io/badge/python-3.8-blue.svg)](https://www.python.org/downloads/release/python-380/)



  `aioupnp` is a python 3.6-8 library and command line tool to interact with UPnP gateways using asyncio. `aioupnp` requires the `netifaces` and `defusedxml` modules.


  ![img](https://i.imgur.com/JtO4glP.png)



  Verify python is version 3.6-8
  ```
  python --version
  ```


  ```
  pip install aioupnp
  ```


  ```
  git clone https://github.com/lbryio/aioupnp.git
  cd aioupnp
  pip install -e .
  ```




  ```
  aioupnp [-h] [--debug_logging] [--interface=<interface>] [--gateway_address=<gateway_address>]
          [--lan_address=<lan_address>] [--timeout=<timeout>]
          [(--<case sensitive m-search header>=<value>)...]
          command [--<arg name>=<arg>]...
  ```



  * `help`
  * `get_external_ip`
  * `m_search`
  * `add_port_mapping`
  * `get_port_mapping_by_index`
  * `get_redirects`
  * `get_specific_port_mapping`
  * `delete_port_mapping`
  * `get_next_mapping`
  * `gather_debug_info`



      aioupnp help get_external_ip



      aioupnp get_external_ip



      aioupnp get_redirects



      aioupnp add_port_mapping --external_port=1234 --internal_port=1234 --lan_address=<lan_addr> --description=test --protocol=TCP



      aioupnp delete_port_mapping --external_port=1234 --protocol=TCP


  UPnP uses a multicast protocol (SSDP) to locate the gateway. Gateway discovery is automatic by default, but you may provide specific headers for the search to use to override automatic discovery.

  If m-search headers are provided as keyword arguments then all of the headers to be used must be provided, in the order they are to be used. For example:

      aioupnp --HOST=239.255.255.250:1900 --MAN=\"ssdp:discover\" --MX=1 --ST=upnp:rootdevice m_search


  By default, the network device will be automatically discovered. The interface may instead be specified with the `--interface`, provided before the command to be run. The gateway used on the interface network may be specified with the `--gateway_address` argument.

      aioupnp --interface=wlp4s0 --gateway_address=192.168.1.6 m_search




      from aioupnp.upnp import UPnP

      async def main():
          upnp = await UPnP.discover()
          print(await upnp.get_external_ip())
          print(await upnp.get_redirects())

          print("adding a port mapping")
          await upnp.add_port_mapping(1234, 'TCP', 1234, upnp.lan_address, 'test mapping')
          print(await upnp.get_redirects())

          print("deleting the port mapping")
          await upnp.delete_port_mapping(1234, 'TCP')
          print(await upnp.get_redirects())


      asyncio.run(main())



  If `aioupnp` is failing with m-search timeouts this means the UPnP gateway (the router) isn't being found at all. To see if this error is expected try running m_search with debug logging, which will print out the packets sent and received:

      aioupnp --debug_logging m_search

  If you only see packets being sent or the replies are only from devices that aren't your router (smart devices, speakers, etc), then there are three options:
  * your router does not support UPnP (this is unlikely)
  * UPnP is turned off in the web gui for your router (more likely)
  * `aioupnp` has a bug (very likely if you don't see your router manufacturer doing well in the supported devices table)

  If you see replies from the router but it still fails, then it's likely a bug in aioupnp.

  If there are no replies and UPnP is certainly turned on, then a local firewall is the likely culprit.




  If it still doesn't work, you can send a bug report using an included script. This script will try finding the UPnP gateway using `aioupnp` as well as `miniupnpc` and then try add and remove a port mapping using each library. The script does this while capturing the packets sent/received, which makes figuring out what went wrong possible. The script will create a file with this packet capture (`aioupnp-bug-report.json`) and automatically send it.

  Note: the bug report script currently does not work on MacOS
  ```
  git clone https://github.com/lbryio/aioupnp.git
  cd aioupnp
  python3 -m pip install -e .

  python3 -m pip install --user certifi aiohttp miniupnpc
  sudo -E python3 generate_bug_report.py
  ```



  This project is MIT licensed. For the full license, see [LICENSE](LICENSE).



  The primary contact for this project is [@jackrobison](mailto:jackrobison@lbry.com)


pkgId: 7c35efb599ac08506d3749f02ca1d13f8f44d15c16151d4048a41f5e295bc6b6
name: python-aiovantage
arch: src
version: 0.15.1
epoch: 0
release: 1
summary: Interact with and control Vantage InFusion home automation controllers.
url: https://pypi.org/project/aiovantage/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiovantage-0.15.1-1.src.rpm
checksum_type: sha256
description:
  aiovantage is a Python library for interacting with and controlling Vantage InFusion home automation controllers.

  Uses a *controller* pattern inspired heavily by the [aiohue](https://github.com/home-assistant-libs/aiohue) library.

  This open-source, non-commercial library is not affiliated, associated, authorized, endorsed by, or in any way officially connected with Vantage, and is provided for interoperability purposes only.



  <!-- START doctoc generated TOC please keep comment here to allow auto update -->
  <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->

  - [Example](#example)
  - [Features](#features)
  - [Supported objects types](#supported-objects-types)
  - [Installation](#installation)
  - [Usage](#usage)

  <!-- END doctoc generated TOC please keep comment here to allow auto update -->



  ```python
  from aiovantage import Vantage

  async with Vantage("192.168.1.2", "username", "password") as vantage:
      async for load in vantage.loads:
          print(f"{load.name} is at {load.level}%")
  ```

  See the [examples](examples) folder for more examples.



  - Uses Python asyncio for non-blocking I/O.
  - Exposes "controllers" to make fetching and controlling various objects easy.
  - Uses SSL connections by default, with automatic reconnection.
  - Fetch objects lazily (with `async for obj in controller`).
  - Alternatively, eager-fetch objects with `controller.initialize`.



  The following interfaces/controllers are currently supported.

  | Type          | Description           | Controller                    | Examples                                  |
  | ------------- | --------------------- | ----------------------------- | ----------------------------------------- |
  | AnemoSensor   | Wind speed sensors    | `vantage.anemo_sensors`       | [Examples](examples/anemo_sensors)        |
  | Area          | Rooms, etc            | `vantage.areas`               | [Examples](examples/areas)                |
  | Blind         | Shades, blinds        | `vantage.blinds`              | [Examples](examples/blinds)               |
  | BlindGroups   | Groups of blinds      | `vantage.blind_groups`        | [Examples](examples/blind_groups)         |
  | Buttons       | Keypad buttons        | `vantage.buttons`             | [Examples](examples/buttons)              |
  | DryContacts   | Motion sensors, etc   | `vantage.dry_contacts`        | [Examples](examples/dry_contacts)         |
  | GMem          | Vantage variables     | `vantage.gmem`                | [Examples](examples/gmem)                 |
  | LightSensor   | Light sensors         | `vantage.light_sensors`       | [Examples](examples/light_sensors)        |
  | Load          | Lights, relays, etc   | `vantage.loads`               | [Examples](examples/loads)                |
  | LoadGroup     | Groups of loads       | `vantage.load_groups`         | [Examples](examples/load_groups)          |
  | Master        | Vantage controllers   | `vantage.masters`             | [Examples](examples/masters)              |
  | Module        | Dimmer modules        | `vantage.modules`             |                                           |
  | OmniSensor    | Power, current, etc   | `vantage.omni_sensors`        | [Examples](examples/omni_sensors)         |
  | PowerProfile  | Load power profiles   | `vantage.power_profiles`      | [Examples](examples/power_profiles)       |
  | RGBLoad       | RGB lights            | `vantage.rgb_loads`           | [Examples](examples/rgb_loads)            |
  | Stations      | Keypads, etc          | `vantage.stations`            | [Examples](examples/stations)             |
  | Tasks         | Vantage tasks         | `vantage.tasks`               | [Examples](examples/tasks)                |
  | Temperature   | Temperature sensors   | `vantage.temperature_sensors` | [Examples](examples/temperature_sensors)  |
  | Thermostat    | Thermostats           | `vantage.thermostats`         | [Examples](examples/thermostats)          |

  If you have an object that you expect to show up in one of these controllers but is missing, please [create an issue](issues) or [submit a pull request](CONTRIBUTING.md#-adding-support-for-new-devices).



  Add `aiovantage` as a dependency to your project, or install it directly:

  ```shell
  pip install aiovantage
  ```





  Begin by importing the `Vantage` class:

  ```python
  from aiovantage import Vantage
  ```

  The most convenient way to create a client is by using the async context manager:

  ```python
  async with Vantage("hostname", "username", "password") as vantage:
      
  ```

  Alternatively, you can manage the lifecycle of the client yourself:

  ```python
  from aiovantage import Vantage

  vantage = Vantage("hostname", "username", "password")

  vantage.close()
  ```



  The `Vantage` class exposes a number of *controllers*, which can be used to query objects. Controllers can either be populated lazily (by using `async for`), or eagerly (by using `controller.initialize()`).

  For example, to get a list of all loads:

  ```python
  async with Vantage("hostname", "username", "password") as vantage:
      async for load in vantage.loads:
          print(f"{load.name} is at {load.level}%")
  ```

  Alternatively, you can use `controller.initialize()` to eagerly fetch all objects:

  ```python
  async with Vantage("hostname", "username", "password") as vantage:
      await vantage.loads.initialize()
      for load in vantage.loads:
          print(f"{load.name} is at {load.level}%")
  ```

  If you aren't interested in the state of the objects, you can call `controller.initialize(fetch_state=False)` to slightly speed up the initialization:

  ```python
  async with Vantage("hostname", "username", "password") as vantage:
      await vantage.loads.initialize(fetch_state=False)
      for load in vantage.loads:
          print(f"{load.name}")
  ```

  All controllers implement a django-like query interface, which can be used to filter objects. You can either query by matching attributes:

  ```python
  async with Vantage("hostname", "username", "password") as vantage:
      async for load in vantage.loads.filter(name="Kitchen"):
          print(f"{load.name} is at {load.level}%")
  ```

  Or by using a filter predicate:

  ```python
  async with Vantage("hostname", "username", "password") as vantage:
      async for load in vantage.loads.filter(lambda load: load.level > 50):
          print(f"{load.name} is at {load.level}%")
  ```



  You can fetch a single object by id, by calling `controller.aget()` or `controller.get()`:

  ```python
  async with Vantage("hostname", "username", "password") as vantage:
      load = await vantage.loads.aget(118)
      print(f"{load.name} is at {load.level}%")
  ```

  These functions also implement the same query interface as `controller.filter()` for querying by
  attributes or filter predicate:

  ```python
  async with Vantage("hostname", "username", "password") as vantage:
      load = await vantage.loads.aget(name="Kitchen")
      print(f"{load.name} is at {load.level}%")
  ```



  Most controllers expose a various methods for controlling the state of objects. The first parameter to these methods is always the vantage id of the object to control.

  For example, to turn on a load:

  ```python
  async with Vantage("hostname", "username", "password") as vantage:
      await vantage.loads.turn_on(118)
  ```



  You can subscribe to state changes by using the `controller.subscribe()` method:

  ```python
  def on_load_state_change(event, load, data):
      print(f"{load.name} is at {load.level}%")

  async with Vantage("hostname", "username", "password") as vantage:
      vantage.loads.subscribe(on_load_state_change)
      await vantage.loads.initialize()
  ```

  Note that a subscription will only receive state changes for objects that have populated into the controller.


pkgId: 23ef91a35b1099b5384f0e0092e4a408a833617ce074758416752e9a22bdd454
name: python-aioviberbot
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Viber Python Bot Async API
url: https://github.com/antonmyronyuk/aioviberbot
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioviberbot-0.7.0-1.src.rpm
checksum_type: sha256
description:
  This is async version of [viberbot](https://github.com/Viber/viber-bot-python) package. Fully compatible with sync package version.
  Use this library to develop a bot for Viber platform.

  The library is available on [GitHub](https://github.com/antonmyronyuk/aioviberbot) as well as a package on [PyPI](https://pypi.org/project/aioviberbot/).

  This package can be imported using pip by adding the following to your `requirements.txt`:

  ```python
  aioviberbot==0.7.0
  ```



  This library is released under the terms of the Apache 2.0 license. See [License](https://github.com/antonmyronyuk/aioviberbot/blob/main/LICENSE.md) for more information.



  1. python >= 3.7.0
  1. An Active Viber account on a platform which supports Public Accounts/ bots (iOS/Android). This account will automatically be set as the account administrator during the account creation process.
  1. Active Public Account/bot - Create an account [here](https://partners.viber.com/account/create-bot-account).
  1. Account authentication token - unique account identifier used to validate your account in all API requests. Once your account is created your authentication token will appear in the account’s “edit info” screen (for admins only). Each request posted to Viber by the account will need to contain the token.
  1. Webhook - Please use a server endpoint URL that supports HTTPS. If you deploy on your own custom server, you'll need a trusted (ca.pem) certificate, not self-signed. Read our [blog post](https://developers.viber.com/blog/2017/05/24/test-your-bots-locally) on how to test your bot locally.



  If you think that there's a bug or there's anything else needed to be changed and you want to change it yourself, you can always create a new Pull request.
  Please make sure that your change doesn't break anything and all the unit tests passes.
  Also, please make sure that the current tests cover your change, if not please add tests.

  We are using pytest, so if you want to run the tests from the commandline just follow the relevant steps after cloning the repo and creating your branch:


  ```

  python setup.py develop


  pytest tests/
  ```






  Creating a basic Viber bot is simple:

  1. Install the library with pip `pip install aioviberbot`
  2. Import `aioviberbot.api` library to your project
  3. Create a Public Account or bot and use the API key from [https://developers.viber.com](https://developers.viber.com)
  4. Configure your bot as described in the documentation below
  5. Start your web server
  6. Call `set_webhook(url)` with your web server url





  ```python
  from aioviberbot import Api
  from aioviberbot.api.bot_configuration import BotConfiguration

  bot_configuration = BotConfiguration(
      name='PythonSampleBot',
      avatar='http://viber.com/avatar.jpg',
      auth_token='YOUR_AUTH_TOKEN_HERE',
  )
  viber = Api(bot_configuration)
  ```



  Next thing you should do is starting a https server.
  and yes, as we said in the prerequisites it has to be https server. Create a server however you like, for example with `aiohttp`:

  ```python
  from aiohttp import web


  async def webhook(request: web.Request) -> web.Response:
      request_data = await request.read()
      logger.debug('Received request. Post data: %s', request_data)
      
      return web.json_response({'ok': True})


  if __name__ == '__main__':
      app = web.Application()
      app.router.add_route('POST', '/webhook', webhook),
      web.run_app(app)
  ```



  After the server is up and running you can set a webhook.
  Viber will push messages sent to this URL. web server should be internet-facing.

  ```python
  await viber.set_webhook('https://mybotwebserver.com:443/')
  ```



  This library uses the standard python logger. If you want to see its logs you can configure the logger:

  ```python
  logger = logging.getLogger('aioviberbot')
  logger.setLevel(logging.DEBUG)
  handler = logging.StreamHandler()
  formatter = logging.Formatter('s - s - s - s')
  handler.setFormatter(formatter)
  logger.addHandler(handler)
  ```


  Well, funny you ask. Yes we do. All the Message types are located in `aioviberbot.api.messages` package. Here's some examples:

  ```python
  from aioviberbot.api.messages import (
      TextMessage,
      ContactMessage,
      PictureMessage,
      VideoMessage,
  )
  from aioviberbot.api.messages.data_types.contact import Contact


  text_message = TextMessage(text='sample text message!')


  contact = Contact(name='Viber user', phone_number='0123456789')
  contact_message = ContactMessage(contact=contact)


  picture_message = PictureMessage(text='Check this', media='http://site.com/img.jpg')


  video_message = VideoMessage(media='http://mediaserver.com/video.mp4', size=4324)
  ```

  Have you noticed how we created the `TextMessage`? There's all bunch of message types you should get familiar with.

  * [Text Message](#TextMessage)
  * [Url Message](#UrlMessage)
  * [Contact Message](#ContactMessage)
  * [Picture Message](#PictureMessage)
  * [Video Message](#VideoMessage)
  * [Location Message](#LocationMessage)
  * [Sticker Message](#StickerMessage)
  * [Rich Media Message](#RichMediaMessage)
  * [Keyboard Message](#KeyboardMessage)

  Creating them is easy! Every message object has it's own unique constructor corresponding to it's API implementation, click on them to see it!
  Check out the full API documentation for more advanced uses.



  ```python
  from aiohttp import web

  from aioviberbot import Api
  from aioviberbot.api.bot_configuration import BotConfiguration
  from aioviberbot.api.messages.text_message import TextMessage
  from aioviberbot.api.viber_requests import ViberConversationStartedRequest
  from aioviberbot.api.viber_requests import ViberMessageRequest
  from aioviberbot.api.viber_requests import ViberSubscribedRequest

  viber = Api(BotConfiguration(
      name='PythonSampleBot',
      avatar='http://viber.com/avatar.jpg',
      auth_token='YOUR_AUTH_TOKEN_HERE'
  ))


  async def webhook(request: web.Request) -> web.Response:
      request_data = await request.read()
      signature = request.headers.get('X-Viber-Content-Signature')
      if not viber.verify_signature(request_data, signature):
          raise web.HTTPForbidden

      viber_request = viber.parse_request(request_data)
      if isinstance(viber_request, ViberMessageRequest):
          
          await viber.send_messages(
              viber_request.sender.id,
              [viber_request.message],
          )
      elif isinstance(viber_request, ViberSubscribedRequest):
          await viber.send_messages(
              viber_request.user.id,
              [TextMessage(text='Thanks for subscribing!')],
          )
      elif isinstance(viber_request, ViberConversationStartedRequest):
          await viber.send_messages(
              viber_request.user.id,
              [TextMessage(text='Thanks for starting conversation!')],
          )

      return web.json_response({'ok': True})


  async def set_webhook_signal(app: web.Application):
      await viber.set_webhook('https://mybotwebserver.com/webhook')


  if __name__ == '__main__':
      app = web.Application()
      app.on_startup.append(set_webhook_signal)
      app.router.add_route('POST', '/webhook', webhook),
      web.run_app(app)
  ```

  As you can see there's a bunch of `Request` types here's a list of them.





  `from aioviberbot import Api`

  * Api
      * [init(bot\_configuration, client\_session)](#new-Api())
      * [.set\_webhook(url, webhook_events)](#set_webhook) ⇒ `List of registered event_types`
      * [.unset\_webhook()](#unset_webhook) ⇒ `None`
      * [.get\_account_info()](#get_account_info) ⇒ `object`
      * [.verify\_signature(request\_data, signature)](#verify_signature) ⇒ `boolean`
      * [.parse\_request(request\_data)](#parse_request) ⇒ `ViberRequest`
      * [.send\_messages(to, messages)](#send_messages) ⇒ `list of message tokens sent`
      * [.broadcast\_messages(broadcast\_list, messages)](#broadcast_messages) ⇒ `list of message tokens sent`
      * [.get\_online(viber\_user\_ids)](#get_online) ⇒ `dictionary of users status`
      * [.get\_user_details(viber\_user\_id)](#get_user_details) ⇒ `dictionary of user's data`
      * [.post\_messages\_to\_public\_account(to, messages)](#post_to_pa) ⇒ `list of message tokens sent`

  <a name="new-Api()"></a>



  | Param              | Type     | Description                                                                                 |
  |--------------------|----------|---------------------------------------------------------------------------------------------|
  | bot\_configuration | `object` | `BotConfiguration`                                                                          |
  | client\_session    | `object` | Optional `aiohttp.ClientSession`, pass if you want to use your own session for api requests |

  <a name="set_webhook"></a>



  | Param | Type | Description |
  | --- | --- | --- |
  | url | `string` | Your web server url |
  | webhook\_events | `list` | optional list of subscribed events |
  | send\_name | `bool` | optional should receive the user name |
  | send\_photo | `bool` | optional should receive the user photo |

  Returns `List of registered event_types`.

  ```python
  event_types = await viber.set_webhook('https://example.com/webhook')
  ```

  <a name="unset_webhook"></a>



  Returns `None`.

  ```python
  await viber.unset_webhook()
  ```

  <a name="get_account_info"></a>



  Returns an `object` [with the following JSON](https://developers.viber.com/docs/api/rest-bot-api/#get-account-info).

  ```python
  account_info = await viber.get_account_info()
  ```

  <a name="verify_signature"></a>



  | Param | Type | Description |
  | --- | --- | --- |
  | request\_data | `string` | the post data from request |
  | signature | `string` | sent as header `X-Viber-Content-Signature` |


  Returns a `boolean` suggesting if the signature is valid.

  ```python
  if not viber.verify_signature(await request.read(), request.headers.get('X-Viber-Content-Signature')):
      raise web.HTTPForbidden
  ```

  <a name="parse_request"></a>



  | Param | Type | Description |
  | --- | --- | --- |
  | request\_data | `string` | the post data from request |

  Returns a `ViberRequest` object.

  There's a list of [ViberRequest objects](#ViberRequest)

  ```python
  viber_request = viber.parse_request(await request.read())
  ```

  <a name="send_messages"></a>



  | Param | Type | Description |
  | --- | --- | --- |
  | to | `string` | Viber user id |
  | messages | `list` | list of `Message` objects |

  Returns `list` of message tokens of the messages sent.

  ```python
  tokens = await viber.send_messages(
      to=viber_request.sender.id,
      messages=[TextMessage(text='sample message')],
  )
  ```

  <a name="broadcast_messages"></a>



  | Param | Type   | Description               |
  | --- |--------|---------------------------|
  | broadcast_list | `list` | list of Viber user ids    |
  | messages | `list` | list of `Message` objects |

  Returns `list` of message tokens of the messages sent.

  ```python
  tokens = await viber.broadcast_messages(
      broadcast_list=[
          "ABB102akPCRKFaqxWnafEIA==",
          "ABB102akPCRKFaqxWna111==",
          "ABB102akPCRKFaqxWnaf222==",
      ],
      messages=[TextMessage(text='sample message')],
  )
  ```

  <a name="post_to_pa"></a>



  | Param | Type | Description |
  | --- | --- | --- |
  | sender | `string` | Viber user id |
  | messages | `list` | list of `Message` objects |

  Returns `list` of message tokens of the messages sent.

  ```python
  tokens = await viber.post_messages_to_public_account(
      sender=viber_request.sender.id,
      messages=[TextMessage(text='sample message')],
  )
  ```

  <a name="get_online"></a>



  | Param | Type | Description |
  | --- | --- | --- |
  | viber\_user\_ids | `array of strings` | Array of Viber user ids |

  Returns a `dictionary of users`.

  ```python
  users = await viber.get_online(['user1id', 'user2id'])
  ```

  <a name="get_user_details"></a>



  | Param | Type | Description |
  | --- | --- | --- |
  | viber\_user\_ids | `string` | Viber user id |

  The `get_user_details` function will fetch the details of a specific Viber user based on his unique user ID. The user ID can be obtained from the callbacks sent to the account regarding user's actions. This request can be sent twice during a 12 hours period for each user ID.

  ```python
  user_data = await viber.get_user_details('userId')
  ```

  <a name="ViberRequest"></a>



  | Param | Type | Notes |
  | --- | --- | --- |
  | event\_type | `string` | according to `EventTypes` enum |
  | timestamp | `long` | Epoch of request time |

  * ViberRequest
      * .event\_type ⇒ `string `
      * .timestamp ⇒ `long`

  <a name="ConversationStarted"></a>



  Inherits from [ViberRequest](#ViberRequest)

  Conversation started event fires when a user opens a conversation with the Public Account/ bot using the “message” button (found on the account’s info screen) or using a [deep link](https://developers.viber.com/docs/tools/deep-links).

  This event is **not** considered a subscribe event and doesn't allow the account to send messages to the user; however, it will allow sending one "welcome message" to the user. See [sending a welcome message](#SendingWelcomeMessage) below for more information.

  | Param | Type | Notes |
  | --- | --- | --- |
  | event\_type | `string` | always equals to the value of `EventType.CONVERSATION_STARTED` |
  | message\_token | `string` | Unique ID of the message |
  | type | `string` | The specific type of `conversation_started` event. |
  | context | `string` | Any additional parameters added to the deep link used to access the conversation passed as a string |
  | user | `UserProfile` | the user started the conversation [UserProfile](#UserProfile) |
  | subscribed | `boolean` | Indicates whether a user is already subscribed |

  * ViberConversationStartedRequest
      * message\_token ⇒ `string`
      * type ⇒ `string`
      * context ⇒ `string`
      * user ⇒ `UserProfile`



  Inherits from [ViberRequest](#ViberRequest)

  | Param | Type | Notes |
  | --- | --- | --- |
  | event\_type | `string` | always equals to the value of `EventType.DELIVERED` |
  | message\_token | `string` | Unique ID of the message |
  | user\_id | `string` | Unique Viber user id |

  * ViberDeliveredRequest
      * message\_token ⇒ `string`
      * user\_id ⇒ `string`



  Inherits from [ViberRequest](#ViberRequest)

  | Param | Type | Notes |
  | --- | --- | --- |
  | event\_type | `string` | always equals to the value of `EventType.FAILED` |
  | message\_token | `string` | Unique ID of the message |
  | user\_id | `string` | Unique Viber user id |
  | desc | `string` | Failure description |

  * ViberFailedRequest
      * message\_token ⇒ `string`
      * user\_id ⇒ `string`
      * desc ⇒ `string`



  Inherits from [ViberRequest](#ViberRequest)

  | Param | Type | Notes |
  | --- | --- | --- |
  | event\_type | `string` | always equals to the value of `EventType.MESSAGE` |
  | message\_token | `string` | Unique ID of the message |
  | message | `Message` | `Message` object |
  | sender | `UserProfile` | the user started the conversation [UserProfile](#UserProfile) |

  * ViberMessageRequest
      * message\_token ⇒ `string`
      * message ⇒ `Message`
      * sender ⇒ `UserProfile`



  Inherits from [ViberRequest](#ViberRequest)

  | Param | Type | Notes |
  | --- | --- | --- |
  | event\_type | `string` | always equals to the value of `EventType.SEEN` |
  | message\_token | `string` | Unique ID of the message |
  | user\_id | `string` | Unique Viber user id |

  * ViberSeenRequest
      * message\_token ⇒ `string`
      * user\_id ⇒ `string`



  Inherits from [ViberRequest](#ViberRequest)

  | Param | Type | Notes |
  | --- | --- | --- |
  | event\_type | `string` | always equals to the value of `EventType.SUBSCRIBED` |
  | user | `UserProfile` | the user started the conversation [UserProfile](#UserProfile) |

  * ViberSubscribedRequest
      * user ⇒ `UserProfile`



  Inherits from [ViberRequest](#ViberRequest)

  | Param | Type | Notes |
  | --- | --- | --- |
  | event\_type | `string` | always equals to the value of `EventType.UNSUBSCRIBED` |
  | user\_id | `string` | Unique Viber user id |

  * ViberUnsubscribedRequest
      * get\_user\_id() ⇒ `string`

  <a name="UserProfile"></a>



  | Param | Type | Notes |
  | --- | --- | --- |
  | id | `string` | --- |
  | name | `string` | --- |
  | avatar | `string` | Avatar URL |
  | country | `string` | **currently set in `CONVERSATION_STARTED` event only** |
  | language | `string` | **currently set in `CONVERSATION_STARTED` event only** |

  <a name="MessageObject"></a>



  **Common Members for `Message` interface**:

  | Param | Type | Description |
  | --- | --- | --- |
  | timestamp | `long` | Epoch time |
  | keyboard | `JSON` | keyboard JSON |
  | trackingData | `JSON` | JSON Tracking Data from Viber Client |

  **Common Constructor Arguments `Message` interface**:

  | Param | Type | Description |
  | --- | --- | --- |
  | optionalKeyboard | `JSON` | [Writing Custom Keyboards](https://developers.viber.com/docs/tools/keyboards) |
  | optionalTrackingData | `JSON` | Data to be saved on Viber Client device, and sent back each time message is received |

  <a name="TextMessage"></a>



  | Member | Type
  | --- | --- |
  | text | `string` |

  ```python
  message = TextMessage(text='my text message')
  ```

  <a name="UrlMessage"></a>



  | Member | Type | Description |
  | --- | --- | --- |
  | media | `string` | URL string |

  ```python
  message = URLMessage(media='http://my.siteurl.com')
  ```

  <a name="ContactMessage"></a>



  | Member | Type
  | --- | --- |
  | contact | `Contact` |

  ```python
  from aioviberbot.api.messages.data_types.contact import Contact

  contact = Contact(name='Viber user', phone_number='+0015648979', avatar='http://link.to.avatar')
  contact_message = ContactMessage(contact=contact)
  ```

  <a name="PictureMessage"></a>



  | Member | Type | Description |
  | --- | --- | --- |
  | media | `string` | url of the message (jpeg only) |
  | text | `string` |  |
  | thumbnail | `string` |  |

  ```python
  message = PictureMessage(media='http://www.thehindubusinessline.com/multimedia/dynamic/01458/viber_logo_JPG_1458024f.jpg', text='Viber logo')
  ```

  <a name="VideoMessage"></a>



  | Member | Type | Description |
  | --- | --- | --- |
  | media | `string` | url of the video |
  | size | `int` |  |
  | thumbnail | `string` |  |
  | duration | `int` |  |

  ```python
  message = VideoMessage(media='http://site.com/video.mp4', size=21499)
  ```

  <a name="LocationMessage"></a>



  | Member | Type
  | --- | --- |
  | location | `Location` |

  ```python
  from aioviberbot.api.messages.data_types.location import Location

  location = Location(lat=0.0, lon=0.0)
  location_message = LocationMessage(location=location)
  ```

  <a name="StickerMessage"></a>



  | Member | Type
  | --- | --- |
  | sticker\_id | `int` |

  ```python
  message = StickerMessage(sticker_id=40100)
  ```

  <a name="FileMessage"></a>



  | Member | Type
  | --- | --- |
  | media | `string` |
  | size | `long` |
  | file\_name | `string` |

  ```python
  message = FileMessage(media=url, size=size_in_bytes, file_name=file_name)
  ```

  <a name="RichMediaMessage"></a>



  | Member | Type
  | --- | --- |
  | rich\_media | `string` (JSON) |

  ```python
  SAMPLE_RICH_MEDIA = """{
    "BgColor": "#69C48A",
    "Buttons": [
      {
        "Columns": 6,
        "Rows": 1,
        "BgColor": "#454545",
        "BgMediaType": "gif",
        "BgMedia": "http://www.url.by/test.gif",
        "BgLoop": true,
        "ActionType": "open-url",
        "Silent": true,
        "ActionBody": "www.tut.by",
        "Image": "www.tut.by/img.jpg",
        "TextVAlign": "middle",
        "TextHAlign": "left",
        "Text": "<b>example</b> button",
        "TextOpacity": 10,
        "TextSize": "regular"
      }
    ]
  }"""

  SAMPLE_ALT_TEXT = 'upgrade now!'

  message = RichMediaMessage(rich_media=SAMPLE_RICH_MEDIA, alt_text=SAMPLE_ALT_TEXT)
  ```

  <a name="KeyboardMessage"></a>



  | Member | Type
  | --- | --- |
  | keyboard | `JSON` |
  | tracking_data | `JSON` |

  ```python
  message = KeyboardMessage(tracking_data=tracking_data, keyboard=keyboard)
  ```

  <a name="SendingWelcomeMessage"></a>



  The Viber API allows sending messages to users only after they subscribe to the account. However, Viber will allow the account to send one “welcome message” to a user as the user opens the conversation, before the user subscribes.

  The welcome message will be sent as a response to a `conversation_started` callback, which will be received from Viber once the user opens the conversation with the account. To learn more about this event and when is it triggered see [`Conversation started`](#ConversationStarted) in the callbacks section.



  Sending a welcome message will be done according to the following flow:

  1. User opens 1-on-1 conversation with account.
  2. Viber server send `conversation_started` even to PA’s webhook.
  3. The account receives the `conversation_started` and responds with an HTTP response which includes the welcome message as the response body.

  The welcome message will be a JSON constructed according to the send_message requests structure, but without the `receiver` parameter. An example welcome message would look like this:

  ```python
  async def webhook(request: web.Request) -> web.Response:
      request_data = await request.read()
      viber_request = viber.parse_request(request_data)

      if isinstance(viber_request, ViberConversationStartedRequest):
          await viber.send_messages(
              viber_request.user.id,
              [TextMessage(text='Welcome!')],
          )

      return web.json_response({'ok': True})
  ```



  Join the conversation on **[Gitter](https://gitter.im/viber/bot-python)**.


pkgId: d3eda1e0e1d70c181f475e7a577d2fd44abc260c3a2f2656910734f76d315bef
name: python-aiovlc
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Control VLC over telnet connection using asyncio
url: https://github.com/MartinHjelmare/aiovlc
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiovlc-0.6.0-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://aiovlc.readthedocs.io" target="_blank">https://aiovlc.readthedocs.io </a>


pkgId: 12a69dbb367933514a5795c09f3f1b1b32d54e89e525aad4c2be37dc8a5bf8ee
name: python-aiovodafone
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Python library to control Vodafone Station
url: https://github.com/chemelli74/aiovodafone
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiovodafone-0.6.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/chemelli74/aiovodafone/actions/workflows/ci.yml?query=branch%3Amain">
      <img src="https://img.shields.io/github/actions/workflow/status/chemelli74/aiovodafone/ci.yml?branch=main&label=CI&logo=github&style=flat-square" alt="CI Status" >
    </a>
    <a href="https://codecov.io/gh/chemelli74/aiovodafone">
      <img src="https://img.shields.io/codecov/c/github/chemelli74/aiovodafone.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/aiovodafone/">
      <img src="https://img.shields.io/pypi/v/aiovodafone.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/aiovodafone.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
    <img src="https://img.shields.io/pypi/l/aiovodafone.svg?style=flat-square" alt="License">
  </p>

  Python library to control Vodafone Station



  Install this via pip (or your favourite package manager):

  `pip install aiovodafone`



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- prettier-ignore-start -->
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- markdownlint-disable -->
  <!-- markdownlint-enable -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-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
  [Copier](https://copier.readthedocs.io/) and the
  [browniebroke/pypackage-template](https://github.com/browniebroke/pypackage-template)
  project template.


pkgId: 7292246aa5cb950af18de2f5589df36c2e85d52f7fb607ae0f4722ab2849d2ad
name: python-aiowaqi
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Asynchronous Python client for WAQI API.
url: https://github.com/joostlek/python-waqi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiowaqi-3.1.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Release][releases-shield]][releases]
  [![Python Versions][python-versions-shield]][pypi]
  ![Project Stage][project-stage-shield]
  ![Project Maintenance][maintenance-shield]
  [![License][license-shield]](LICENSE.md)

  [![Build Status][build-shield]][build]
  [![Code Coverage][codecov-shield]][codecov]
  [![Code Smells][code-smells]][sonarcloud]

  Asynchronous Python client for the WAQI API.



  This package allows you to request data about air quality around the world.



  ```bash
  pip install aiowaqi
  ```



  ```python
  import asyncio

  from aiowaqi import WAQIClient


  async def main() -> None:
      """Show example of fetching air quality for Utrecht."""
      async with WAQIClient() as client:
          client.authenticate("token")
          air_quality = await client.get_by_city("utrecht")
          print(air_quality)


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



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

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

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



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

  We've set up a separate document for our
  [contribution guidelines](.github/CONTRIBUTING.md).

  Thank you for being involved! :heart_eyes:



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

  You need at least:

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

  To install all packages, including all development requirements:

  ```bash
  npm install
  poetry install
  ```

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

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

  To run just the Python tests:

  ```bash
  poetry run pytest
  ```



  The content is by [Joost Lekkerkerker][joostlek].

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



  MIT License

  Copyright (c) 2023-2024 Joost Lekkerkerker

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

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

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

  [build-shield]: https://github.com/joostlek/python-waqi/actions/workflows/tests.yaml/badge.svg
  [build]: https://github.com/joostlek/python-waqi/actions
  [code-smells]: https://sonarcloud.io/api/project_badges/measure?project=joostlek_python-waqi&metric=code_smells
  [codecov-shield]: https://codecov.io/gh/joostlek/python-waqi/branch/master/graph/badge.svg
  [codecov]: https://codecov.io/gh/joostlek/python-waqi
  [commits-shield]: https://img.shields.io/github/commit-activity/y/joostlek/python-waqi.svg
  [commits]: https://github.com/joostlek/python-waqi/commits/master
  [contributors]: https://github.com/joostlek/python-waqi/graphs/contributors
  [frenck]: https://github.com/frenck
  [joostlek]: https://github.com/joostlek
  [keepchangelog]: http://keepachangelog.com/en/1.0.0/
  [license-shield]: https://img.shields.io/github/license/joostlek/python-waqi.svg
  [maintenance-shield]: https://img.shields.io/maintenance/yes/2024.svg
  [poetry-install]: https://python-poetry.org/docs/#installation
  [poetry]: https://python-poetry.org
  [pre-commit]: https://pre-commit.com/
  [project-stage-shield]: https://img.shields.io/badge/project%20stage-stable-green.svg
  [python-versions-shield]: https://img.shields.io/pypi/pyversions/aiowaqi
  [releases-shield]: https://img.shields.io/github/release/joostlek/python-waqi.svg
  [releases]: https://github.com/joostlek/python-waqi/releases
  [semver]: http://semver.org/spec/v2.0.0.html
  [sonarcloud]: https://sonarcloud.io/summary/new_code?id=joostlek_python-waqi
  [pypi]: https://pypi.org/project/aiowaqi/


pkgId: 6ffac4fdecb2d2b6787877d42fa87c828913e5b5fa9f787691011a40dc96e1dc
name: python-aiowatttime
arch: src
version: 2024.6.0
epoch: 0
release: 1
summary: An asyncio-based Python3 library for interacting with WattTime
url: https://github.com/bachya/aiowatttime
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiowatttime-2024.6.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>

  `aiowatttime` is a Python 3, asyncio-friendly library for interacting with
  [WattTime](https://www.watttime.org) emissions data.

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



  `aiowatttime` is currently supported on:

  - Python 3.10
  - Python 3.11
  - Python 3.12



  ```bash
  pip install aiowatttime
  ```





  Simply clone this repo and run the included interactive script:

  ```bash
  $ script/register
  ```

  Note that WattTime offers three plans: Visitors, Analyst, and Pro. The type you use
  will determine which elements of this library are available to use. You can read more
  details [here][watttime-data-plans].



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

  ```python
  import asyncio

  from aiowatttime import Client


  async def main() -> None:
      client = await Client.login("<USERNAME>", "<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 Client.login("<USERNAME>", "<PASSWORD>", session=session)
          


  asyncio.run(main())
  ```



  ```python
  await client.async_request_password_reset()
  ```





  It may be useful to first get the "grid region" (i.e., geographical info) for the area
  you care about:

  ```python
  await client.emissions.async_get_grid_region(
      "<LATITUDE>", "<LONGITUDE>", "<SIGNAL_TYPE>"
  )

  ```

  Getting emissions data will require the region abbreviation (`PSCO` in the example above).



  ```python
  await client.emissions.async_get_realtime_emissions("<REGION>")

  {"data": [...]}
  ```



  ```python
  from datetime import datetime

  await client.emissions.async_get_forecasted_emissions(
      "<REGION>", "<SIGNAL_TYPE>", datetime(2021, 1, 1), datetime(2021, 2, 1)
  )

  ```



  ```python
  await client.emissions.async_get_forecasted_emissions(
      "<REGION>", "<SIGNAL_TYPE>", datetime(2021, 1, 1), datetime(2021, 2, 1)
  )

  ```



  By default, `aiowatttime` will handle expired access tokens for you. When a token expires,
  the library will attempt the following sequence 3 times:

  - Request a new token
  - Pause for 1 second (to be respectful of the API rate limiting)
  - Execute the original request again

  Both the number of retries and the delay between retries can be configured when
  instantiating a client:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from aiowatttime import Client


  async def main() -> None:
      async with ClientSession() as session:
          client = await Client.async_login(
              "user",
              "password",
              session=session,
              
              request_retries=7,
              
              request_retry_delay=4,
          )


  asyncio.run(main())
  ```

  As always, an invalid username/password combination will immediately throw an exception.



  By default, `aiowatttime` provides its own logger. If you should wish to use your own, you
  can pass it to the client during instantiation:

  ```python
  import asyncio
  import logging

  from aiohttp import ClientSession

  from aiowatttime import Client

  CUSTOM_LOGGER = logging.getLogger("my_custom_logger")


  async def main() -> None:
      async with ClientSession() as session:
          client = await Client.async_login(
              "user",
              "password",
              session=session,
              logger=logger,
          )


  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 aiowatttime 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/aiowatttime/test.yml
  [ci]: https://github.com/bachya/aiowatttime/actions
  [codecov-badge]: https://codecov.io/gh/bachya/aiowatttime/branch/dev/graph/badge.svg
  [codecov]: https://codecov.io/gh/bachya/aiowatttime
  [contributors]: https://github.com/bachya/aiowatttime/graphs/contributors
  [fork]: https://github.com/bachya/aiowatttime/fork
  [issues]: https://github.com/bachya/aiowatttime/issues
  [license-badge]: https://img.shields.io/pypi/l/aiowatttime.svg
  [license]: https://github.com/bachya/aiowatttime/blob/main/LICENSE
  [maintainability-badge]: https://api.codeclimate.com/v1/badges/781e64940b1302ae9ac3/maintainability
  [maintainability]: https://codeclimate.com/github/bachya/aiowatttime/maintainability
  [new-issue]: https://github.com/bachya/aiowatttime/issues/new
  [new-issue]: https://github.com/bachya/aiowatttime/issues/new
  [pypi-badge]: https://img.shields.io/pypi/v/aiowatttime.svg
  [pypi]: https://pypi.python.org/pypi/aiowatttime
  [version-badge]: https://img.shields.io/pypi/pyversions/aiowatttime.svg
  [version]: https://pypi.python.org/pypi/aiowatttime
  [watttime]: https://www.watttime.org
  [watttime-data-plans]: https://www.watttime.org/get-the-data/data-plans/


pkgId: dd0a72c2905eac93e916a1b950bb56d8ecf39e803f946fb510afd15258a65da5
name: python-aiowebostv
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Library to control webOS based LG TV devices
url: https://github.com/home-assistant-libs/aiowebostv
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiowebostv-0.4.2-1.src.rpm
checksum_type: sha256
description:
  Python library to control LG webOS based TV devices.

  Based on:
  - `aiopylgtv` library at https://github.com/bendavid/aiopylgtv
  - `bscpylgtv` library at https://github.com/chros73/bscpylgtv


  - Python >= 3.9


  ```bash
  pip install aiowebostv
  ```


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



  ```python
  import asyncio

  from aiowebostv import WebOsClient

  HOST = "192.168.1.39"

  CLIENT_KEY = "140cce792ae045920e14da4daa414582"


  async def main():
      """Basic webOS client example."""

      client = WebOsClient(HOST, CLIENT_KEY)
      await client.connect()

      
      print(f"Client key: {client.client_key}")

      apps = await client.get_apps_all()
      for app in apps:
          print(app)

      await client.disconnect()


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


  ```python
  import asyncio

  from aiowebostv import WebOsClient

  HOST = "192.168.1.39"

  CLIENT_KEY = "140cce792ae045920e14da4daa414582"


  async def on_state_change(client):
      """State changed callback."""
      print("State changed:")
      print(f"System info: {client.system_info}")
      print(f"Software info: {client.software_info}")
      print(f"Hello info: {client.hello_info}")
      print(f"Channel info: {client.channel_info}")
      print(f"Apps: {client.apps}")
      print(f"Inputs: {client.inputs}")
      print(f"Powered on: {client.power_state}")
      print(f"App Id: {client.current_app_id}")
      print(f"Channels: {client.channels}")
      print(f"Current channel: {client.current_channel}")
      print(f"Muted: {client.muted}")
      print(f"Volume: {client.volume}")
      print(f"Sound output: {client.sound_output}")


  async def main():
      """Subscribed State Updates Example."""
      client = WebOsClient(HOST, CLIENT_KEY)
      await client.register_state_update_callback(on_state_change)
      await client.connect()

      
      print(f"Client key: {client.client_key}")

      
      await asyncio.sleep(30)

      await client.disconnect()


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

  Examples can be found in the `examples` folder


pkgId: cd73cf46513c2917fda40141d11949e50a25518113e640dcd0c78fdd59c5cf65
name: python-aiowire
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: A simple event loop using asyncio
url: https://github.com/frobnitzem/aiowire
rpm_license: LGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiowire-3.1.0-1.src.rpm
checksum_type: sha256
description:
  This package implements a ``EventLoop`` class
  that manages concurrent coroutines.
  It is based on the principles of functional
  reactive programming and draws inspiration
  from Haskell's `Control.Wire <https://hackage.haskell.org/package/netwire-4.0.7/docs/Control-Wire.html>`_ library.
  In particular, every co-routine started by the event loop is a ``Wire``.
  ``Wire``-s either return ``None``, indicating they're done, or another
  ``Wire``.
  An example helps explain the idea::
      from aiowire import EventLoop
      event = 0
      async def show_event(ev) -> Optional[Wire]:
          print("Running...")
          event += 1
          await asyncio.sleep(event*0.15)
          print(f"Event {event}")
          if event < 5:
              return Wire(show_event)
          return None
      async with EventLoop(timeout=1) as event:
          event.start(show_event)
          event.start(show_event)
  We start up an event loop and drop in two wires.
  Each runs, then returns the ``show_event`` function.
  The event loop runs those functions next... and so on.
  But since this isn't functional programming.  The wires
  have access to the event loop, and can start more
  tasks.  Easy, right?
  What can I do with it?
  ^^^^^^^^^^^^^^^^^^^^^^
  What if you have a server that's spawning programs,
  working with sockets, and managing timeouts?  Drop
  in one wire for each program, one polling on socket I/O,
  and another acting as a timer (as above).
  Some canonical task types that do these include::
      asyncio.create_subprocess_exec # run a program
      asyncio.sleep # awake the loop after a given time lapse
      zmq.asyncio.Poller.poll # awake the loop after I/O on socket/file
      aiowire.Poller # Wire-y interface to zmq.asyncio.Poller
  Think about each wire as a finite state machine.
  For example,
      flowchart LR
          R[Ready] --> N{New Task?};
          N -- Yes --> W[Working];
          W --> C{Complete?};
          C -- Yes --> R;
  can be implemented like so::
      async def ready(ev : EventLoop, info : X) -> Optional[Wire]:
          if info.new_task():
              do_working_action()
              return Wire(working, info) # move to working state
          
          return Call(asyncio.sleep, 1.0) >> Wire(ready, info)
      async def working(ev : EventLoop, info : X) -> Wire:
          if info.complete():
              do_complete_action()
              return Wire(ready, info)
          await asyncio.sleep(0.5) # directly sleep a bit
          return Wire(working, info)
  Note how your sockets can launch programs, and your program
  results can start/stop sockets, and everyone can start
  background tasks.
  Poller?
  ^^^^^^^
  The ``Poller`` class lets you schedule callbacks in response
  to socket or file-descriptor activity.  Of course, the callbacks
  are wires, and run concurrently.
  Poller is also a Wire, created as,
  `Poller(dictionary mapping sockets / fd-s to callback wires)`.
  You add it to your event loop as usual::
      
      async def echo(ev):
          await sock.send( await sock.recv() )
      todo = { 0:  Call(print, "received input on sys.stdin"),
               sock: Wire(echo)
             }
      async with EventLoop() as ev:
          ev.start( Poller(todo) )
  Tell me more
  ^^^^^^^^^^^^
  Yes, you *could* just send async functions taking one
  argument to ``EventLoop.start``, but where's the fun in
  writing closures everywhere?
  To take it to the next level, aiowire comes with a
  ``Wire`` convenience class that lets you write ``Wire``-s expressively.
  The following class extensions help you make Wire-s out of common
  programming idioms:
  * `Wire(w)`: acts like an identity over "async func(ev):" functions
  * `Repeat(w, n)`: repeat wire ``w`` n times in a row
  * `Forever(w)`: repeat forever -- like `Repeat(w) * infinity`
  * `Call(fn, *args, **kargs)`: call fn (normal or async),
    ignore the return, and exit
  Consider, for example, printing 4 alarms separated by some time interval::
      from aiowire import EventLoop, Call
      prog = ( Call(asyncio.sleep, 0.1) >> Call(print, 'beep\a') ) * 4
      async with EventLoop() as ev:
          ev.start(prog)


pkgId: ab3f9779ead7e4d48a9791d8ef5c8b17f502568cba231c60c026a9b7cf7e88fc
name: python-aiowithings
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Asynchronous Python client for Withings.
url: https://github.com/joostlek/python-withings
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiowithings-3.1.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Release][releases-shield]][releases]
  [![Python Versions][python-versions-shield]][pypi]
  ![Project Stage][project-stage-shield]
  ![Project Maintenance][maintenance-shield]
  [![License][license-shield]](LICENSE.md)

  [![Build Status][build-shield]][build]
  [![Code Coverage][codecov-shield]][codecov]
  [![Code Smells][code-smells]][sonarcloud]

  Asynchronous Python client for Withings.



  This package allows you to fetch data from Withings.



  ```bash
  pip install aiowithings
  ```



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

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

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



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

  We've set up a separate document for our
  [contribution guidelines](.github/CONTRIBUTING.md).

  Thank you for being involved! :heart_eyes:



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

  You need at least:

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

  To install all packages, including all development requirements:

  ```bash
  npm install
  poetry install
  ```

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

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

  To run just the Python tests:

  ```bash
  poetry run pytest
  ```



  The content is by [Joost Lekkerkerker][joostlek].

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



  MIT License

  Copyright (c) 2023-2024 Joost Lekkerkerker

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

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

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

  [build-shield]: https://github.com/joostlek/python-withings/actions/workflows/tests.yaml/badge.svg
  [build]: https://github.com/joostlek/python-withings/actions
  [code-smells]: https://sonarcloud.io/api/project_badges/measure?project=joostlek_python-withings&metric=code_smells
  [codecov-shield]: https://codecov.io/gh/joostlek/python-withings/branch/master/graph/badge.svg
  [codecov]: https://codecov.io/gh/joostlek/python-withings
  [commits-shield]: https://img.shields.io/github/commit-activity/y/joostlek/python-withings.svg
  [commits]: https://github.com/joostlek/python-withings/commits/master
  [contributors]: https://github.com/joostlek/python-withings/graphs/contributors
  [joostlek]: https://github.com/joostlek
  [keepchangelog]: http://keepachangelog.com/en/1.0.0/
  [license-shield]: https://img.shields.io/github/license/joostlek/python-withings.svg
  [maintenance-shield]: https://img.shields.io/maintenance/yes/2024.svg
  [poetry-install]: https://python-poetry.org/docs/#installation
  [poetry]: https://python-poetry.org
  [pre-commit]: https://pre-commit.com/
  [project-stage-shield]: https://img.shields.io/badge/project%20stage-stable-green.svg
  [python-versions-shield]: https://img.shields.io/pypi/pyversions/aiowithings
  [releases-shield]: https://img.shields.io/github/release/joostlek/python-withings.svg
  [releases]: https://github.com/joostlek/python-withings/releases
  [semver]: http://semver.org/spec/v2.0.0.html
  [sonarcloud]: https://sonarcloud.io/summary/new_code?id=joostlek_python-withings
  [pypi]: https://pypi.org/project/aiowithings/


pkgId: 214fbe566d580190491c807799854315fbb570adb276b5d26eeb81a4d35d7da7
name: python-aioworkers-pg
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Module for working with PostgreSQL via asyncpg
url: https://github.com/aioworkers/aioworkers-pg
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioworkers-pg-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/aioworkers/aioworkers-pg/CI)](https://github.com/aioworkers/aioworkers-pg/actions?query=workflow%3ACI)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aioworkers-pg)](https://pypi.org/project/aioworkers-pg)
  [![PyPI](https://img.shields.io/pypi/v/aioworkers-pg)](https://pypi.org/project/aioworkers-pg)

  Asyncpg plugin for `aioworkers`.






  Add this to aioworkers config.yaml:

  ```yaml
  db:
    cls: aioworkers_pg.base.Connector
    dsn: postgresql:///test
  ```

  You can get access to postgres anywhere via context:

  ```python
  await context.db.execute('CREATE TABLE users(id serial PRIMARY KEY, name text)')
  await context.db.execute(users.insert().values(name='Bob'))
  ```



  ```yaml
  db:
    cls: aioworkers_pg.base.Connector
    dsn: postgresql:///test
    pool:
      min_size: 1
      max_size: 100
  ```




  ```yaml
  storage:
    cls: aioworkers_pg.storage.RoStorage
    dsn: postgresql:///test
    table: mytable  # optional instead custom sql
    key: id
    get: SELECT * FROM mytable WHERE id = :id  # optional custom sql
    format: dict  # or row
  ```



  Install dev requirements:

  ```shell
  poetry install
  ```

  Run postgres:

  ```shell
  docker run --rm -p 5432:5432 --name postgres -e POSTGRES_PASSWORD=postgres -e POSTGRES_DB=test -d postgres
  ```

  Run tests:

  ```shell
  pytest
  ```


pkgId: 820c834e584677c0dfd182784d6087cb2a0a78444cf0355bb262f9f57912e6c5
name: python-aiowowapi
arch: src
version: 2.1.5
epoch: 0
release: 1
summary: An asynchronous Python wrapper for the World of Warcraft APIs.
url: https://github.com/Adalyia/aiowowapi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiowowapi-2.1.5-1.src.rpm
checksum_type: sha256
description:
  Warning: I have personally stopped playing World of Warcraft, if you'd like to take over maintenance of the project or see any issues you can create an issue on GitHub and I promise I'll look into it ASAP.
  An asynchronous client library for interacting with the World of Warcraft API endpoints using the ``async`` / ``await`` syntax.


pkgId: 19ae2853d9ed48cd052ea0259b4e8c6d5ee7f9f7447c3a46fe8989935620adb0
name: python-aioxcom
arch: src
version: 1.5.0
epoch: 0
release: 1
url: https://github.com/ankohanse/aioxcom
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioxcom-1.5.0-1.src.rpm
checksum_type: sha256
summary:
  Async python library to communicate with Studer-Innotec devices on the local network via Xcom protocol

description:
  [![license](https://img.shields.io/github/license/toreamun/amshan-homeassistant?style=for-the-badge)](LICENSE)
  [![buy_me_a_coffee](https://img.shields.io/badge/If%20you%20like%20it-Buy%20me%20a%20coffee-yellow.svg?style=for-the-badge)](https://www.buymeacoffee.com/ankohanse)




  Python library for retrieving sensor information from Studer-Innotec devices.
  This component connects directly over the local network using the Studer xcom protocol.

  The custom component was tested with:
  - Xtender XTH 8000-48 (but should also work for other XTH, XTS and XTM)
  - Xcom-CAN (BSP connection to a third party BMS)
  - Xcom-LAN (which actually is a Xcom232i with a Moxy NPort 5110A)
  - RCC-03

  It should also be able to detect and handle
  - Studer BMS
  - VarioTrack
  - VarioString
  - RCC-02

  Disclaimer: this library is NOT created by Studer-Innotec, but is based on their documentation of the Xcom protocol.
  That documentation can be found on:
  [Studer-Innotec Download Center](https://www.studer-innotec.com/en/downloads/) *-> Software and Updates -> Communication protocol Xcom-232i*




  This device depends on having a Studer Xcom-LAN (i.e. an Xcom-232i and a Moxa ethernet gateway) acting as a Xcom client and connecting to this integration. For older systems this will be a separate component, for future systems Studer have indicated that LAN connection will become part of the Xtender range.

  The Studer Xcom-LAN will be able to simultaneously send data to the Studer online portal as well as sending data to this integration.

  Configuration steps:

  1. Download and install the Moxa DSU tool (Device Search Utility)
      - Open [www.moxa.com](https://www.moxa.com) in a browser
      - Select Support -> Software and Documentation
      - Choose NPort 5100A series (or whatever specific device you have)
      - Scroll down under 'Related Software, Firmware and Drivers' to find 'Device Search Utility'
      - Download and install the utility

  2. Locate the Moxa NPort device on the local network
      - Run the Moxa Device Search Utility
      - Press the 'Search' button and wait until the search finishes
      - The utility should display the found NPort device
      - Double click on the found device to open its configuration page

        ![dsu_search_results](documentation/DSU_results.png)

  3. Configure the Moxa NPort device
      - In the Main Menu, select 'Operating Settings' -> Port 1
      - Verify that 'Operation Mode' is set to 'TCP Client'
      - Add the ip-address or network name of your HomeAssistant as 'Destination IP address'
      - Press the 'Submit' button
      - Press 'Save/Restart'

        ![moxa_operating_settings](documentation/Moxa_operating_settings.png)




  The library is available from PyPi using:
  `pip install aioxcom`

  To read an infos or param or write to a param:

  ```
  from aioxcom import XcomApiTcp, XcomDataset, VOLTAGE

  dataset = await XcomDataset.create(VOLTAGE.AC240) # or use VOLTAGE.AC120
  info_3023 = dataset.getByNr(3023, "xt")  # the "xt" part is optional but usefull for detecting mistakes
  info_6001 = dataset.getByNr(6001, "bsp")
  param_1107 = dataset.getByNr(1107, "xt")
  dataset = None  # Release memory of the dataset

  api = XcomApiTcp(4001)    # port number configured in Xcom-LAN/Moxa NPort
  try:
      if not await api.start():
          logger.info(f"Did not connect to Xcom")
          return

      
      value = await api.requestValue(info_3023, "XT1")    # xt address range is 101 to 109, or use "XT1" to "XT9"
      logger.info(f"XT1 3023: {value} {info_3023.unit} ({info_3023.name})")

      
      value = await api.requestValue(info_6001, "BSP")    # bsp address range is only 601, or use "BSP"
      logger.info(f"BSP 6001: {value} {info_6001.unit} ({info_6001.name})")

      
      value = 4.0    # 4 Ampere
      if await api.updateValue(param_1107, value, "XT1"):
          logger.info(f"XT1 1107 updated to {value} {param_1107.unit} ({param_1107.name})")

  finally:
      await api.stop()
  ```

  A complete list of param and infos numbers can be found in the source of this library in file `src/aioxcom/xcom_datapoints_240v.json`

  A complete list of all available device families and their address range can be found in file `src/aioxcom/xcom_families.py`




  When the value of a Studer param is changed via this library, these are written via Xcom to the affected device.
  Changes are stored in the device's RAM memory, not in its flash memory as you can only write to flash a limited number of time over its lifetime.

  However, reading back the value from the entity will always be from flash. As a result, the change to the entity value is not visible. You can only tell from the behavior of the PV system that the Studer param was indeed changed.
  After a restart/reboot of the PV system the system will revert to the value from Flash. So you may want to periodically repeat the write of changed param values via an automation.

  **IMPORTANT**:

  Be very carefull in changing params marked as having level Expert, Installer or even Qualified Service Person. If you do not know what the effect of a Studer param change is, then do not change it.




  Special thanks to the following people for providing the information this library is based on:
  - [zocker-160](https://github.com/zocker-160/xcom-protocol)
  - [Michael Jeffers](https://community.home-assistant.io/u/JeffersM)


pkgId: be5f4f31979589dd0456936453ad357cd7bc4f81e18244c3421751a531c3fdd2
name: python-aioxcom
arch: src
version: 1.6.0
epoch: 0
release: 1
url: https://github.com/ankohanse/aioxcom
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioxcom-1.6.0-1.src.rpm
checksum_type: sha256
summary:
  Async python library to communicate with Studer-Innotec devices on the local network via Xcom protocol

description:
  [![license](https://img.shields.io/github/license/toreamun/amshan-homeassistant?style=for-the-badge)](LICENSE)
  [![buy_me_a_coffee](https://img.shields.io/badge/If%20you%20like%20it-Buy%20me%20a%20coffee-yellow.svg?style=for-the-badge)](https://www.buymeacoffee.com/ankohanse)




  Python library for retrieving sensor information from Studer-Innotec devices.
  This component connects directly over the local network using the Studer xcom protocol.

  The custom component is comfirmed to be compatible with:
  - Xtender XTH 8000-48, XTM 4000
  - Xcom-CAN (BSP connection to a third party BMS)
  - Xcom-LAN (which actually is a Xcom232i with a Moxy NPort 5110A)
  - BMS
  - RCC-03
  - VarioTrack

  It should also be able to detect and handle
  - Xtender (any other XTH, XTS and XTM models)
  - VarioString
  - RCC-02

  Disclaimer: this library is NOT created by Studer-Innotec, but is based on their documentation of the Xcom protocol.
  That documentation can be found on:
  [Studer-Innotec Download Center](https://www.studer-innotec.com/en/downloads/) *-> Software and Updates -> Communication protocol Xcom-232i*




  This device depends on having a Studer Xcom-LAN (i.e. an Xcom-232i and a Moxa ethernet gateway) acting as a Xcom client and connecting to this integration. For older systems this will be a separate component, for future systems Studer have indicated that LAN connection will become part of the Xtender range.

  The Studer Xcom-LAN will be able to simultaneously send data to the Studer online portal as well as sending data to this integration.

  Configuration steps:

  1. Download and install the Moxa DSU tool (Device Search Utility)
      - Open [www.moxa.com](https://www.moxa.com) in a browser
      - Select Support -> Software and Documentation
      - Choose NPort 5100A series (or whatever specific device you have)
      - Scroll down under 'Related Software, Firmware and Drivers' to find 'Device Search Utility'
      - Download and install the utility

  2. Locate the Moxa NPort device on the local network
      - Run the Moxa Device Search Utility
      - Press the 'Search' button and wait until the search finishes
      - The utility should display the found NPort device
      - Double click on the found device to open its configuration page

        ![dsu_search_results](documentation/DSU_results.png)

  3. Configure the Moxa NPort device
      - In the Main Menu, select 'Operating Settings' -> Port 1
      - Verify that 'Operation Mode' is set to 'TCP Client'
      - Add the ip-address or network name of your HomeAssistant as 'Destination IP address'
      - Press the 'Submit' button
      - Press 'Save/Restart'

        ![moxa_operating_settings](documentation/Moxa_operating_settings.png)




  The library is available from PyPi using:
  `pip install aioxcom`

  To read an infos or param or write to a param:

  ```
  from aioxcom import XcomApiTcp, XcomDataset, VOLTAGE

  dataset = await XcomDataset.create(VOLTAGE.AC240) # or use VOLTAGE.AC120
  info_3023 = dataset.getByNr(3023, "xt")  # the "xt" part is optional but usefull for detecting mistakes
  info_6001 = dataset.getByNr(6001, "bsp")
  param_1107 = dataset.getByNr(1107, "xt")
  dataset = None  # Release memory of the dataset

  api = XcomApiTcp(4001)    # port number configured in Xcom-LAN/Moxa NPort
  try:
      if not await api.start():
          logger.info(f"Did not connect to Xcom")
          return

      
      value = await api.requestValue(info_3023, "XT1")    # xt address range is 101 to 109, or use "XT1" to "XT9"
      logger.info(f"XT1 3023: {value} {info_3023.unit} ({info_3023.name})")

      
      value = await api.requestValue(info_6001, "BSP")    # bsp address range is only 601, or use "BSP"
      logger.info(f"BSP 6001: {value} {info_6001.unit} ({info_6001.name})")

      
      value = 4.0    # 4 Ampere
      if await api.updateValue(param_1107, value, "XT1"):
          logger.info(f"XT1 1107 updated to {value} {param_1107.unit} ({param_1107.name})")

  finally:
      await api.stop()
  ```

  A complete list of param and infos numbers can be found in the source of this library in file `src/aioxcom/xcom_datapoints_240v.json`

  A complete list of all available device families and their address range can be found in file `src/aioxcom/xcom_families.py`




  When the value of a Studer param is changed via this library, these are written via Xcom to the affected device.
  Changes are stored in the device's RAM memory, not in its flash memory as you can only write to flash a limited number of time over its lifetime.

  However, reading back the value from the entity will always be from flash. As a result, the change to the entity value is not visible. You can only tell from the behavior of the PV system that the Studer param was indeed changed.
  After a restart/reboot of the PV system the system will revert to the value from Flash. So you may want to periodically repeat the write of changed param values via an automation.

  **IMPORTANT**:

  Be very carefull in changing params marked as having level Expert, Installer or even Qualified Service Person. If you do not know what the effect of a Studer param change is, then do not change it.




  Special thanks to the following people for providing the information this library is based on:
  - [zocker-160](https://github.com/zocker-160/xcom-protocol)
  - [Michael Jeffers](https://community.home-assistant.io/u/JeffersM)


pkgId: cd496d253d2195dbd694738a287868e04206694c4ac41a7ab37eb686cf33ec78
name: python-aioxdl
arch: src
version: 0.0.30
epoch: 0
release: 1
summary: Python fast downloader
url: https://github.com/Clinton-Abraham
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioxdl-0.0.30-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      📦 <a href="https://pypi.org/project/aioxdl" style="text-decoration:none;">AIO DOWNLOADER</a>
  </p>

  <p align="center">
     <a href="https://telegram.me/clinton_abraham"><img src="https://img.shields.io/badge/𝑪𝒍𝒊𝒏𝒕𝒐𝒏 𝑨𝒃𝒓𝒂𝒉𝒂𝒎-30302f?style=flat&logo=telegram" alt="telegram badge"/></a>
     <a href="https://telegram.me/Space_x_bots"><img src="https://img.shields.io/badge/Sᴘᴀᴄᴇ ✗ ʙᴏᴛꜱ-30302f?style=flat&logo=telegram" alt="telegram badge"/></a>
     <a href="https://telegram.me/sources_codes"><img src="https://img.shields.io/badge/Sᴏᴜʀᴄᴇ ᴄᴏᴅᴇꜱ-30302f?style=flat&logo=telegram" alt="telegram badge"/></a>
  </p>


  ```bash
  pip install aioxdl
  ```



  ```python
  import time
  import asyncio
  from aioxdl.modules import Aioxdl
  from aioxdl.modules import Filename

  async def progress(tsize, dsize, stime):
      
      
      
      percentage = round((dsize / tsize) * 100, 2)
      print("\rCOMPLETED : {}%".format(percentage), end="", flush=True)

  async def main():
      core = Aioxdl(timeout=2000)
      link = "https://example.link/file.txt"
      loca = await Filename.filename(link)
      file = await core.download(link, loca.result, progress=progress, progress_args=(time.time()))
      fine = file.result if file.errors == None else file.errors
      print(fine)

  asyncio.run(main())
  ```


  ```python
  from aioxdl.modules import Filename

  async def main():
      link = "https://example.link/file.txt"
      name = await Filename.get(link)
      print(name.result)

  asyncio.run(main())
  ```



  ```python
  import time
  import asyncio
  from aioxdl.modules import Aioxdl
  from aioxdl.modules import Filename
  from aioxdl.functions import Cancelled

  TASK_ID = []

  async def progress(tsize, dsize, stime, tuid):
      
      
      
      if tuid in TASK_ID:
          percentage = round((dsize / tsize) * 100, 2)
          print("\rCOMPLETED : {}%".format(percentage), end="", flush=True)
      else:
          raise Cancelled("Cancelled ❌")

  async def main():
      tims = time.time()
      tuid = 1234567890
      TASK_ID.append(tuid)
      core = Aioxdl(timeout=2000)
      link = "https://example.uri/file.txt"
      loca = await Filename.filename(link)
      file = await core.download(link, loca.result,
                                 progress=progress, progress_args=(tims, tuid))
      if file.status == 400:
          print(file.errors)
      elif file.status == 300:
          print("Cancelled ❌")
      else:
          print(fine.result)

  asyncio.run(main())
  ```


pkgId: c76d68772996e9271948a6523f26a5535597603a380a29df657d183f077bc910
name: python-aioyagmail
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Yet Another GMAIL client, using AsyncIO
url: https://github.com/kootenpv/aioyagmail
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioyagmail-0.0.4-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="./resources/icon.png" width="48px"/>
  </p>



  [![Join the chat at https://gitter.im/kootenpv/aioyagmail](https://badges.gitter.im/kootenpv/aioyagmail.svg)](https://gitter.im/kootenpv/aioyagmail?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![PyPI](https://img.shields.io/pypi/v/aioyagmail.svg?style=flat-square)](https://pypi.python.org/pypi/aioyagmail/)
  [![PyPI](https://img.shields.io/pypi/pyversions/aioyagmail.svg?style=flat-square)](https://pypi.python.org/pypi/aioyagmail/)

  The goal here is to make it as simple and painless as possible to send emails using asyncio.

  In the end, your code will look something like this:

  ```python
  import asyncio
  from aioyagmail import AIOSMTP

  loop = asyncio.get_event_loop()

  async def send_single():
      
      async with AIOSMTP(oauth2_file="~/oauth2_gmail.json") as yag:
          await yag.send(to="someone@gmail.com", subject="hi")

  async def send_multi():
      async with AIOSMTP(oauth2_file="~/oauth2_gmail.json") as yag:
          
          await asyncio.gather(yag.send(subject="1"),
                               yag.send(subject="2"),
                               yag.send(subject="3"))

  loop.run_until_complete(send_single())
  loop.run_until_complete(send_multi())
  ```



  It is possible like in `yagmail` to use username and password, but this is not actively encouraged anymore.
  See https://github.com/kootenpv/yagmail#username-and-password how to do it.



  Have a look at `yagmail`. Any issue NOT related to async should be posted there (or found out about).



  Watch out that gmail does not block you for spamming. Using async you could potentially be sending emails too rapidly.



  If you like `aioyagmail`, feel free (no pun intended) to donate any amount you'd like :-)

  [![PayPal](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Y7QCCEPGC6R5E)


pkgId: ee599cf2951e38d6acdc15564d2af33af8e2e367184b41a1a76faae55cceb889
name: python-aioyoomoney-api
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: Async Yoomoney API
url: https://pypi.org/project/aioyoomoney-api/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aioyoomoney-api-0.0.10-1.src.rpm
checksum_type: sha256
description:
  Implemented methods:
  -   [Access token](#access-token) - Getting an access token
  -   Account information - Getting information about the status of the
      user account.
  -   [Operation history](#operation-history) - This method allows viewing the full or partial
      history of operations in page mode. History records are displayed in
      reverse chronological order (from most recent to oldest).
  -   [Operation details](#operation-details) - Provides detailed information about a
      particular operation from the history.
  -   [Quickpay forms](#quickpay-forms) - The YooMoney form is a set of fields with
      information about a transfer. You can embed payment form into your
      interface (for instance, a website or blog). When the sender pushes
      the button, the details from the form are sent to YooMoney and an
      order for a transfer to your wallet is initiated.


pkgId: f7d3c278362c44043bebf62c5b0f16c3b072100980dda89ad2d7cf935ee4a5c1
name: python-aiozabbix
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Asynchronous Zabbix API Python interface
url: https://gitlab.com/ModioAB/aiozabbix
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiozabbix-1.3.1-1.src.rpm
checksum_type: sha256
description:
  **aiozabbix** is a Python package that provides an asynchronous
  interface to the
  [Zabbix API](https://www.zabbix.com/documentation/3.0/manual/api/reference),
  using aiohttp. It is based on
  [PyZabbix](https://github.com/lukecyca/pyzabbix).


pkgId: b4e4005bd9462d0fc43a5b82585b48686e94377c269f52ad8d426b89baecd976
name: python-aiozipkin
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Distributed tracing instrumentation for asyncio application with zipkin
url: https://github.com/aio-libs/aiozipkin
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiozipkin-1.1.1-1.src.rpm
checksum_type: sha256
description:
  **aiozipkin** is Python 3.6+ module that adds distributed tracing capabilities
  from asyncio_ applications with zipkin (http://zipkin.io) server instrumentation.
  zipkin_ is a distributed tracing system. It helps gather timing data needed
  to troubleshoot latency problems in microservice architectures. It manages
  both the collection and lookup of this data. Zipkin’s design is based on
  the Google Dapper paper.
  Applications are instrumented with  **aiozipkin** report timing data to zipkin_.
  The Zipkin UI also presents a Dependency diagram showing how many traced
  requests went through each application. If you are troubleshooting latency
  problems or errors, you can filter or sort all traces based on the
  application, length of trace, annotation, or timestamp.


pkgId: 791ce53f113d7c9b2d26b2705a3472e4dce31ea11ba6364ed357c7515214b577
name: python-aiozipstream
arch: src
version: 0.4
epoch: 0
release: 1
summary: Creating zip files on the fly
url: https://github.com/kbbdy/zipstream
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiozipstream-0.4-1.src.rpm
checksum_type: sha256
description:
  This is a fork of [ZipStream](https://github.com/kbbdy/zipstream). Simple python library for streaming ZIP files which are created dynamically, without using any temporary files.

  - No temporary files, data is streamed directly
  - Supported `deflate` compression method
  - Small memory usage, straming is realised using yield statement
  - Archive structure is created on the fly, and all data can be created during stream
  - Files included into archive can be generated on the fly using Python generators
  - Asynchronous AioZipStream and classic ZipStream are available
  - Zip32 format compatible files
  - Independent from python's standard ZipFile implementation
  - Almost no dependencies: only `aiofiles` in some circumstances (see AioZipStream section for details)
  - Zip64 support is also planned in future (far future, because I never hitted 4GB file size limit ;-) )



  `ZipStream` is compatible with **Python 2.7**.

  `AioZipStream` require **Python 3.6**. For earlier versions `AioZipStream` is not available for import.




  List of files to archive is stored as list of dicts. Why dicts? Because there are possible additional parameters for each file, and more parameters are planned in future.

  Sample list of files to archive:

  ```python
  files = [
           
           {'file':'/tmp/file.dat'},

           
           
           {'file':'/tmp/file.dat',
            'name':'completly_different.foo',
            'compression':'deflate'}
          ]
  ```

  It's time to stream / archive:

  ```python
  zs = ZipStream(files)
  with open("example.zip", "wb") as fout:
      for data in zs.stream():
          fout.write(data)
  ```

  Any iterable source of binary data can be used in place of regular files. Using generator as input for file must be represented by `stream` field instead of `file`, additional `name` parameter is also required.

  ```python

  def source_of_bytes():
      yield b"123456789"
      yield b"abcdefgh"
      yield b"I am a binary data"

  files = [....
           
           {'stream': source_of_bytes(), 'name': 'my_data.bin'},
          ]
  ```

  Keep in mind, that data should be served in chunks of reasonable size, because in case of using stream, `ZipStream` class is not able to split data by self.

  List of files to stream can be also generated on the fly, during streaming:

  ```python
  import os
  from zipstream import ZipStream

  def files_to_stream_with_foo_in_name(dirname):
      
      for f in os.listdir(dirname):
          fp = os.path.join(dirname, f)
          if os.path.isfile(fp):
              yield {'file': fp,
                     'name': "foo_" + os.path.basename(fp)}
      
      yield {'stream': source_of_bytes(),
             'name': 'my_data.bin',
             'compression': 'deflate'}

  zs = ZipStream(files_to_stream_with_foo_in_name('\tmp\some-files'))
  ```



  :warning: **To use asynchronous AioZipStream at least Python 3.6 version is required**. AioZipStream is using asynchronous generator syntax, wchich is avilable from 3.6 version.

  To work with local files addtional `aiofiles` library is required. If You plan to stream only dynamically generated content, then `aiofiles` is not required.

  See [aiofiles github repo](https://github.com/Tinche/aiofiles) for details about `aiofiles`.




  Any generator used to create data on the fly, must be defined as `async`:

  ```python
  async def content_generator():
      yield b'foo baz'
      asyncio.sleep(0.1) # we simulate little slow source of data
      data = await remote_data_source()
      yield bytes(data, 'utf-8') # always remember to yield binary data
      asyncio.sleep(0.5)
      yield b"the end"
  ```

  Also zip streaming must be inside `async` function. Note usage `aiofiles.open` instead of `open`, which is asynchronous and will not block event loop during disk access.

  ```python
  from zipstream import AioZipStream

  async def zip_async(zipname, files):
      aiozip = AioZipStream(files, chunksize=32768)
      async with aiofiles.open(zipname, mode='wb') as z:
          async for chunk in aiozip.stream():
              await z.write(chunk)
  ```

  Here is going list of files to send:

  ```python
  files = [
      {'file': '/tmp/car.jpeg'},
      {'file': '/tmp/aaa.mp3', 'name': 'music.mp3'},
      {'stream': content_generator(),
       'name': 'random_stuff.txt'}
  ]
  ```

  Start asyncio loop and stream result to file:

  ```python
  loop = asyncio.get_event_loop()
  loop.run_until_complete(zip_async('example.zip', files))
  loop.stop()
  ```



  See `examples` directory for complete code and working examples of ZipStream and AioZipStream.


pkgId: b63f9e63af61abf1eaf74f47293d76a6b9b4495f3d02481f8235a0976473d729
name: python-aiozk
arch: src
version: 0.31.1
epoch: 0
release: 1
summary: Asyncio client for Zookeeper.
url: http://github.com/micro-fan/aiozk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiozk-0.31.1-1.src.rpm
checksum_type: sha256
description:
  Ran 3 tests in 1.059s
  OK
  ```
  Run tests locally:
  ```sh

  ZK_HOST=<ZK_IP> ./venv/bin/pytest
  ```

  It seems that usually recipes require several things to be tested:
  * That recipe flow is working as expected
  * Timeouts: reproduce every timeout with meaningful values (timeout 0.5s and block for 0.6s)

  Another way to run tests only which you are interested in quickly. Or this is
  useful when you run tests under the other version of python.
  ```sh

  docker run -p 2181:2181 zookeeper

  export ZK_HOST=localhost
  pytest -s --log-cli-level=DEBUG aiozk/test/test_barrier.py
  ```

  * It is based on [wglass/zoonado](https://github.com/wglass/zoonado/tree/master/zoonado) implementation


pkgId: 2d98d6e1a31a89074d07e5dbc961d477902aa08cdaf11641d70be0a93b90844f
name: python-aiozmq
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: ZeroMQ integration with asyncio.
url: http://aiozmq.readthedocs.org
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiozmq-1.0.0-1.src.rpm
checksum_type: sha256
description:
  asyncio (PEP 3156) support for ZeroMQ.
  The difference between ``aiozmq`` and vanilla ``pyzmq`` (``zmq.asyncio``) is:
  ``zmq.asyncio`` works only by replacing the *base event loop* with a custom one.
  This approach works but has two disadvantages:
  1. ``zmq.asyncio.ZMQEventLoop`` cannot be combined with
     other loop implementations (most notable is the ultra fast ``uvloop``).
  2. It uses the internal ZMQ Poller which has fast ZMQ Sockets support
     but isn't intended to work fast with many (thousands) regular TCP sockets.
     In practice it means that ``zmq.asyncio`` is not recommended to be used with
     web servers like ``aiohttp``.
     See also https://github.com/zeromq/pyzmq/issues/894


pkgId: b38ac54e026ad6359bc07858c86fb6b720a1713e1794a9f7c71a7c1df3bf7879
name: python-aiozoneinfo
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Tools to fetch zoneinfo with asyncio
url: https://github.com/bluetooth-devices/aiozoneinfo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiozoneinfo-0.2.1-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://aiozoneinfo.readthedocs.io" target="_blank">https://aiozoneinfo.readthedocs.io </a>


pkgId: a0b40e8b2fd64618ba605bfb77acd97b59c573cfd57e43d516a9512c515916cc
name: python-aiozoom
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: Async library for interaction with Zoom API
url: https://github.com/vladisa88/aiozoom
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiozoom-0.0.9-1.src.rpm
checksum_type: sha256
description:
  ![](https://travis-ci.com/vladisa88/aiozoom.svg?branch=main) [![CodeFactor](https://www.codefactor.io/repository/github/vladisa88/aiozoom/badge)](https://www.codefactor.io/repository/github/vladisa88/aiozoom) [![PyPI Version](https://img.shields.io/pypi/v/aiozoom)](https://pypi.org/project/aiozoom/)





  1. Python 3.9
  2. pip




  1. In the console, run the following command:
  ```bash
  pip install --upgrade aiozoom
  ```




  1. Import module
  ```python
  from aiozoom import Zoom
  ```

  2. Configure a Client
  ```python
  from aiozoom import Zoom

  Zoom.configure('JWT_TOKEN')
  ```

  3. Create a meeting
  ```python
  import asyncio

  from aiozoom import Zoom

  Zoom.configure('JWT_TOKEN')
  async def main():
      zoom = Zoom()
      await zoom.create_meeting('example@example.com', {'title': 'test'})

  loop = asyncio.get_event_loop()
  task = loop.create_task(main())
  loop.run_until_complete(task)
  loop.close()

  ```



  ```create_meeting(email, body)```

  ```get_meeting(meeting_id)```

  ```stop_meeting(meeting_id)```

  ```delete_meeting(meeting_id)```

  ```update_meeting(meeting_id, body)```

  ```get_meeting_participants(meeting_id)```

  ```get_meeting_info(meeting_id)```

  and more...


pkgId: 34bd0b2393c0c5259ec937f629d1ba7c5f8b506e1d7f779a62a0c002973bd486
name: python-aipatt
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: AIPATT: AI Powered Assistant Tool for Terminals
url: https://pypi.org/project/aipatt/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aipatt-1.0.5-1.src.rpm
checksum_type: sha256
description:
  <!-- PROJECT LOGO -->
  ![AIPATT](https://img.shields.io/badge/AIPATT-Tool-blue) ![PyPI](https://img.shields.io/pypi/v/aipatt)
  <div align=center>



  A versatile terminal-based AI Powered Assistant Tool.

  [View Demo](https://github.com/someshsce/aipatt) · [Report Bug](https://github.com/someshsce/aipatt/issues/new?labels=bug&template=bug-report---.md) · [Request Feature](https://github.com/someshsce/aipatt/issues/new?labels=enhancement&template=feature-request---.md)

  </div>

  <!-- TABLE OF CONTENTS -->
  <details>
    <summary>Table of Contents</summary>

  1. [About The Project](#about-the-project)
     - [Built With](#built-with)
  2. [Getting Started](#getting-started)
     - [Prerequisites](#prerequisites)
     - [Installation](#installation)
     - [Configuration](#configuration)
  3. [Usage](#usage)
  4. [Contributing](#contributing)
  5. [License](#license)
  6. [Contact](#contact)

  </details>

  <!-- ABOUT THE PROJECT -->


  <div align=center>

  </div>
  <br />

  AIPATT is an AI-powered Assistance Tool for Terminals designed to streamline your workflow by providing tools to generate code, execute shell commands, retrieve and summarize information from Google, and engage in interactive chats.

  Here's why:

  - **Boost productivity**: AIPATT helps automate repetitive tasks like coding, information retrieval, and system commands right from the terminal.
  - **Easy integration**: Integrates seamlessly with your command-line environment, making it a powerful addition to your development toolkit.
  - **Versatile**: Whether you're coding, querying data, or managing system tasks, AIPATT adapts to your needs.

  AIPATT is built with an emphasis on simplicity, power, and flexibility, enabling developers and power users to get things done faster and smarter.



  These are the major frameworks and libraries used to build AIPATT:

  - [![Python](https://img.shields.io/badge/Python-3.11.10-snake)](https://www.python.org)
  - [![Ollama](https://img.shields.io/badge/Ollama-v0.4.7-green)](https://ollama.com)
  - [![LLaMa3](https://img.shields.io/badge/LLaMa-3.2-blue)](https://example.com)
  - [![Langchain](https://img.shields.io/badge/Langchain-0.3.9-blue)](https://langchain.com)
  - [![Langgraph](https://img.shields.io/badge/Langgraph-0.2.53-red)](https://example.com)

  <!-- GETTING STARTED -->


  To get a local copy of **AIPATT** up and running, follow these steps.



  Before installing and using **AIPATT**, ensure you have the following installed:

  - **Python 3.10+** - Ensure Python is installed on your system. You can download it from [here](https://www.python.org/downloads/).
  - **Ollama** - To run the language models, you need to install Ollama. You can get Ollama from their [official site](https://ollama.com).
    - Once installed, you can run a model like `llama3.2` using:

      ```sh
      ollama run llama3.2
      ```

    - You can explore other models available on [Ollama's model library](https://ollama.com/search) that supports tools calling.



  Once the prerequisites are installed, follow these steps to install **AIPATT**:

  1. Install **AIPATT** via **pip**:

     ```sh
     pip install aipatt
     ```

  2. After the installation, you can start using AIPATT directly in your terminal by running:

     ```sh
     aipatt
     ```



  The first time you run **AIPATT**, you will need to configure a few settings. You can either use the default settings or customize them as per your needs. Below are the configuration options you'll need to provide:

  1. `DATABASE_PATH`: Default value is available, but you can specify your own database path.
  2. `DEFAULT_MODEL`: Default model is set, but you can change it to any available model in Ollama.
  3. `OPENWEATHERMAP_API_KEY`: You need to get your API key from OpenWeatherMap.
  4. `GOOGLE_SEARCH_URL`: The default Google search URL is set, but you can override it.
  5. `GOOGLE_CSE_ID`: Get your Custom Search Engine ID from Google CSE.
  6. `GOOGLE_API_KEY`: Get your Google API Key from Google Cloud Console.
  7. `SMTP_SERVER`: Default is set for Gmail, but you can configure your own SMTP server.
  8. `PORT`: Default is set for Gmail. If using a different SMTP server, you need to provide the correct port.
  9. `USERNAME`: Your email address or username for the SMTP server.
  10. `PASSWORD`: Your email password or an app-specific password if using Gmail.

  **`Note`**: When you first run AIPATT, it will ask you to enter these configuration values. You can also manually edit the `.aipatt.env` file that is created in the home directory to modify these settings.

  <!-- USAGE EXAMPLES -->


  Here are some useful examples of how you can use **AIPATT** to perform different tasks. Each command can be run directly in your terminal. For more details on the available commands, use the `-h` or `--help` option.

  To see all available options, use:

    ```sh
    aipatt -h
    ```



  `Generate Code`: Use this to generate code based on your input query.

    ```sh
    aipatt -c "Write a Python script for Fibonacci series"
    ```

  `Chat`: Engage in a continuous conversation with the AI.

    ```sh
    aipatt -ch
    ```

  `YouTube Search`: Search and play YouTube videos directly from the terminal.

    ```sh
    aipatt -y "Top Python tutorials"
    ```

  `Shell Command Generation`: Generate and execute shell commands based on a query.

    ```sh
    aipatt -s "How to update my system?"
    ```

  `Mail Composer`: Compose and send an email using AI.

    ```sh
    aipatt -m "Send email to example@gmail.com, Meeting at 10 AM"
    ```

  `Google Search and Summarize`: Search on Google and get a summarized answer.

    ```sh
    aipatt -gs "What is the capital of France?"
    ```

  `Update Configuration`: Use this command to update your configuration settings.

    ```sh
    aipatt -u
    ```

  `Clear Memory`: Clear the entire chat memory.

    ```sh
    aipatt -cm
    ```

  `Version Info`: Get the version of AIPATT installed.

    ```sh
    aipatt -v
    ```

  `Help`: Display the help message with all available options.

    ```sh
    aipatt -h
    ```



  `Ask a Question`: Query the AI to answer questions directly:

    ```sh
    aipatt "What is internet?"
    ```

  `Search Latest News About AI`: Use AIPATT to stay updated with the latest AI news:

    ```sh
    aipatt "Latest news about AI"
    ```

  `Search and Play YouTube Videos`: Search for specific videos on YouTube and play them:

    ```sh
    aipatt -y "Top Python tutorials"
    ```

  `Generate Shell Command`: Run a query and generate a shell command, or execute a script:

    ```sh
    aipatt -s "How to update my system?"
    ```

  `Summarize Google Search Results`: Use AIPATT to search Google and get a summary of the results:

    ```sh
    aipatt -gs "What is the capital of France?"
    ```

  `Current Weather Conditions`: Get the weather report of a city:

    ```sh
    aipatt "Current Weather Condition of New York"
    ```

  `Generate Code`: Generate code for a common task like a Fibonacci series:

    ```sh
    aipatt -c "Write a Python script for Fibonacci series"
    ```

  `Send an Email`: Compose and send an email using AI:

    ```sh
    aipatt -m "Send email to example@gmail.com, Meeting at 10 AM"
    ```

  `Explain Shell Script`: You can even pipe a shell script into AIPATT and get an explanation of the code:

    ```sh
    cat install.sh | aipatt "Explain the code"
    ```

  <!-- Contributing -->


  Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.

  If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".

  Don't forget to give the project a star! Thanks again!



  1. Fork the Project
  2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
  3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to the Branch (`git push origin feature/AmazingFeature`)
  5. Open a Pull Request

  [See](CONTRIBUTING.md) `CONTRIBUTING.md` for more information.

  <!-- LICENSE -->


  Distributed under the [GNU AGPLv3 License](LICENSE). See `LICENSE` for more information.

  <!-- CONTACT -->


  **Author**: `Somesh Sharma`

  <table border="0">
    <tr>
      <td><strong>AIPATT</strong></td>
      <td><a href="https://pypi.org/project/aipatt/">PyPI Link</a></td>
    </tr>
    <tr>
      <td><strong>LinkedIn</strong></td>
      <td><a href="https://www.linkedin.com/in/somesh9">Somesh Sharma</a></td>
    </tr>
    <tr>
      <td><strong>Instagram</strong></td>
      <td><a href="https://www.instagram.com/somesh_el">Somesh Sharma</a></td>
    </tr>
    <tr>
      <td><strong>Email</strong></td>
      <td><a href="mailto:someshs.ce@gmail.com">someshs.ce@gmail.com</a></td>
    </tr>
  </table>

rpm_license:
  GNU AFFERO GENERAL PUBLIC LICENSE Version 3, 19 November 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU Affero General Public License is a free, copyleft license for software and other kinds of works, specifically designed to ensure cooperation with the community in the case of network server software.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, our General Public Licenses are 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.  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.  Developers that use our General Public Licenses protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License which gives you legal permission to copy, distribute and/or modify the software.  A secondary benefit of defending all users' freedom is that improvements made in alternate versions of the program, if they receive widespread use, become available for other developers to incorporate.  Many developers of free software are heartened and encouraged by the resulting cooperation.  However, in the case of software used on network servers, this result may fail to come about. The GNU General Public License permits making a modified version and letting the public access it on a server without ever releasing its source code to the public.  The GNU Affero General Public License is designed specifically to ensure that, in such cases, the modified source code becomes available to the community.  It requires the operator of a network server to provide the source code of the modified version running there to the users of that server.  Therefore, public use of a modified version, on a publicly accessible server, gives the public access to the source code of the modified version.  An older license, called the Affero General Public License and published by Affero, was designed to accomplish similar goals.  This is a different license, not a version of the Affero GPL, but Affero has released a new version of the Affero GPL which permits relicensing under this license.  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 Affero 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. Remote Network Interaction; Use with the GNU General Public License.  Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software.  This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph.  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 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 work with which it is combined will remain governed by version 3 of the GNU General Public License.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU Affero 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 Affero 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 Affero 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 Affero 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.  AIPATT: AI Powered Assistant Tool for Terminals - A versatile terminal-based assistant that can generate code, execute shell commands, search and summarize information from Google, and interact via chat.  Copyright (C) 2024 Somesh Sharma  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 v3.0 along with this program.  If not, see <https://www.gnu.org/licenses/>.  For any inquiries, you can reach me at: someshs.ce@gmail.com  You can access the source code at: https://github.com/someshsce/aipatt  Also add information on how to contact you by electronic and paper mail.  If your software can interact with users remotely through a computer network, you should also make sure that it provides a way for users to get its source.  For example, if your program is a web application, its interface could display a "Source" link that leads users to an archive of the code.  There are many ways you could offer source, and different solutions will be better for different programs; see section 13 for the specific requirements.  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 AGPL, see <https://www.gnu.org/licenses/>.


pkgId: 6c7e1d596598fb454925d0230c5e96c833a26ed9f302b70c60f1470fb00055ec
name: python-aipha-geo-solutions
arch: src
version: 0.9.30
epoch: 0
release: 1
summary: A python API to the AIPHA webservices
url: https://github.com/AIPHA-Geo-Solutions/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aipha-geo-solutions-0.9.30-1.src.rpm
checksum_type: sha256
description:
  This package contains the AIPHA python API. You can install it via:

  	pip install aipha_geo_solutions

  You can find a detailed documentation at the [AIPHA Webservices](https://aipha.ch/documentation)


pkgId: ec361f0adc3c69cd12e5f2f3a7611e90c92ddd915abdcd3f2f11ea0f4caffada
name: python-aipkgs-firebase
arch: src
version: 1.0.26
epoch: 0
release: 1
description: AI's package
url: https://gitlab.com/aipy/public/packages.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aipkgs-firebase-1.0.26-1.src.rpm
checksum_type: sha256
summary:
  A utility package for interacting with Firebase, specifically Firestore, in a more streamlined and efficient manner.


pkgId: eb34a512cfce76a9f97c428de47d86e8f43074519f16bdf665935cd16780b946
name: python-aipocli
arch: src
version: 0.0.1b3
epoch: 0
release: 1
summary: The official Python SDK for the Aipolabs (Aipotheosis Labs) API
url: https://aipolabs.xyz
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aipocli-0.0.1b3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/aipolabs.svg)](https://pypi.org/project/aipolabs/)

  The official Python SDK for the Aipolabs API.
  Currently in private beta, breaking changes are expected.

  The Aipolabs Python SDK provides convenient access to the Aipolabs REST API from any Python 3.10+
  application.


  The REST API documentation is available [here](https://api.aipolabs.xyz/v1/docs).


  ```bash
  pip install aipolabs
  ```

  or with poetry:
  ```bash
  poetry add aipolabs
  ```


  Aipolabs platform is built with agent-first principles. Although you can call each of the APIs below any way you prefer in your application, we strongly recommend trying the [Agent-centric features](#agent-centric-features) and taking a look at the [examples](./examples/README.md) to get the most out of the platform and to enable the full potential and vision of future agentic applications.


  ```python
  from aipolabs import Aipolabs

  client = Aipolabs(
      
      api_key=os.environ.get("AIPOLABS_API_KEY")
  )
  ```



  ```python
  from aipolabs.types.apps import App, AppDetails
  ```


  ```python


  apps: list[App] = client.apps.search(intent="I want to search the web", limit=10, offset=0)
  ```

  ```python

  app_details: AppDetails = client.apps.get(app_name="BRAVE_SEARCH")
  ```



  ```python
  from aipolabs.types.functions import Function, FunctionExecutionResult
  ```


  ```python


  functions: list[Function] = client.functions.search(
      app_names=["BRAVE_SEARCH", "TAVILY"],
      intent="I want to search the web",
      limit=10,
      offset=0
  )
  ```

  ```python


  function_definition: dict = client.functions.get(function_name="BRAVE_SEARCH__WEB_SEARCH")
  ```

  ```python

  result: FunctionExecutionResult = client.functions.execute(
      function_name="BRAVE_SEARCH__WEB_SEARCH",
      function_parameters={"query": "what is the weather in barcelona"}
  )

  if result.success:
      print(result.data)
  else:
      print(result.error)
  ```


  The SDK provides a suite of features and helper functions to make it easier and more seamless to use functions in LLM powered agentic applications.
  This is our vision and the recommended way of trying out the SDK.


  We provide 4 meta functions that can be used with LLMs as tools directly, and a unified handler for function calls. With these the LLM can discover apps and functions (that our platform supports) and execute them autonomously.

  ```python
  from aipolabs import meta_functions


  tools = [
      meta_functions.AipolabsSearchApps.SCHEMA,
      meta_functions.AipolabsSearchFunctions.SCHEMA,
      meta_functions.AipolabsGetFunctionDefinition.SCHEMA,
      meta_functions.AipolabsExecuteFunction.SCHEMA,
  ]
  ```

  ```python

  result = client.handle_function_call(
      tool_call.function.name, json.loads(tool_call.function.arguments)
  )
  ```

  There are mainly two ways to use the platform with the meta functions:

  - **Fully Autonomous**: Provide all 4 meta functions to the LLM, please see the [agent_with_dynamic_function_discovery_and_fixed_tools.py](./examples/agent_with_dynamic_function_discovery_and_fixed_tools.py) for more details.
  - **Semi Autonomous**: Provide all but `AipolabsExecuteFunction` to the LLM, and use the Unified Function Calling Handler to execute functions, please see the [agent_with_dynamic_function_discovery_and_dynamic_tools.py](./examples/agent_with_dynamic_function_discovery_and_dynamic_tools.py) for more details.

  Please also see [agent_with_preplanned_tools.py](./examples/agent_with_preplanned_tools.py) for comparison where the specific functions are pre selected and provided to the LLM.


pkgId: 6c0aafc7e1a282d5cf4e51a1d0950416f75846d0fa6564ca85147dcbce2a46e7
name: python-aipoincare
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: A machine learning package discovering conservation laws.
url: https://pypi.org/project/aipoincare/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aipoincare-0.1.6-1.src.rpm
checksum_type: sha256
description:
  The 'aipoincare' package is available on PyPI and can be installed with `pip install aipoincare`

  Required packages:

  ```python
  numpy
  pytorch
  matplotlib
  flask
  os
  sklearn
  copy
  ```





  ```python
  from aipoincare.main import run

  run()
  ```

  Then play with our GUI ! Have fun !


pkgId: 101b51196e70195800ae143a3c7aaf0b9bb3eea240af27030d574cdf796d5b66
name: python-aipose
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Library to use pose estimation in your projects easily
url: https://github.com/Tlaloc-Es/aipose
rpm_license: https://github.com/Tlaloc-Es/aipose/blob/master/LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aipose-3.0.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  [![Downloads](https://static.pepy.tech/personalized-badge/aipose?period=month&units=international_system&left_color=grey&right_color=blue&left_text=PyPi%20Downloads)](https://pepy.tech/project/aipose)
  [![Stars](https://img.shields.io/github/stars/Tlaloc-Es/aipose?color=yellow&style=flat)](https://github.com/Tlaloc-Es/aipose/stargazers)
  [![Documentation Status](https://readthedocs.org/projects/aipose/badge/?version=latest)](https://aipose.readthedocs.io/en/latest/?badge=latest)
  </div>

  <p align="center">
      <img src="https://raw.githubusercontent.com/Tlaloc-Es/aipose/master/logo.png" width="200" height="240"/>
  </p>

  Library to use pose estimation in your projects easily.


  You can install `aipose` from [Pypi](https://pypi.org/project/aipose/). It's going to install the library itself and its prerequisites as well.

  ```bash
  pip install aipose
  ```

  You can install `aipose` from its source code.

  ```bash
  git clone https://github.com/Tlaloc-Es/aipose.git
  cd aipose
  pip install -e .
  ```



  Use the following command to run a demo with your cam and YOLOv7 pose estimator,

  ```bash
  posewebcam
  ```



  <p align="center">
      <img src="https://raw.githubusercontent.com/Tlaloc-Es/aipose/master/video.gif" width="250" height="200" />
      <img src="https://raw.githubusercontent.com/Tlaloc-Es/aipose/master/video_processed.gif" width="250" height="200" />
  </ p>



  You can check the section notebooks in the repository to check the usage of the library or you can ask in the [Issues section](https://github.com/Tlaloc-Es/aipose/issues).

  The examples are:

  * [How to draw key points in a video](https://github.com/Tlaloc-Es/aipose/blob/master/notebooks/video.ipynb)
  * [How to draw key points in a video and store it](https://github.com/Tlaloc-Es/aipose/blob/master/notebooks/process_and_save_video.ipynb)
  * [How to draw key points in a webcam](https://github.com/Tlaloc-Es/aipose/blob/master/notebooks/webcam.ipynb)
  * [How to draw key points in a picture](https://github.com/Tlaloc-Es/aipose/blob/master/notebooks/plot_keypoints.ipynb)
  * [How to capture a frame to apply your business logic](https://github.com/Tlaloc-Es/aipose/blob/master/notebooks/custom%20manager.ipynb)
  * [How to stop the video stream when anybody raises hands with YOLOv7](https://github.com/Tlaloc-Es/aipose/blob/master/notebooks/process_keypoints.ipynb)
  * [How to calculate pose similarity with YOLOv7](https://github.com/Tlaloc-Es/aipose/blob/master/notebooks/pose_similarity.ipynb)
  * [How to turn the pose with YOLOv7](https://github.com/Tlaloc-Es/aipose/blob/master/notebooks/pose_similarity.ipynb)
  * [How to train a pose classificator](https://github.com/Tlaloc-Es/aipose/blob/master/notebooks/Pose_Classificator.ipynb)



  * https://github.com/RizwanMunawar/yolov7-pose-estimation



  You can do a donation with the following link.

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

  Or you can try to make a pull request with your improvements to the repo.



  * Video by Mikhail Nilov: https://www.pexels.com/video/a-woman-exercising-using-an-exercise-ball-6739975/

  In folder notebooks/poses/

  * [Photo by Roman Davayposmotrim: https://www.pexels.com/photo/woman-wearing-black-sports-bra-reaching-floor-while-standing-35987/](notebooks/poses/pexels-roman-davayposmotrim-35987.jpg)
  * [Photo by Vlada Karpovich: https://www.pexels.com/photo/a-woman-doing-yoga-4534689/](pexels-roman-davayposmotrim-35987.jpg)
  * [Photo by Lucas Pezeta: https://www.pexels.com/photo/woman-doing-yoga-2121049/](notebooks/poses/pexels-lucas-pezeta-2121049)
  * [Photo by Cliff  Booth: https://www.pexels.com/photo/photo-of-woman-in-a-yoga-position-4057839/](pnotebooks/poses/exels-cliff-booth-4057839.jpg)
  * [Photo by Cliff  Booth: https://www.pexels.com/photo/photo-of-woman-meditating-alone-4056969/](notebooks/poses/pexels-cliff-booth-4056969.jpg)
  * [Photo by MART  PRODUCTION: https://www.pexels.com/photo/photo-of-a-woman-meditating-8032834/](notebooks/poses/pexels-mart-production-8032834.jpg)
  * [Photo by Antoni Shkraba: https://www.pexels.com/photo/woman-in-blue-tank-top-and-black-leggings-doing-yoga-4662330/](notebooks/poses/pexels-antoni-shkraba-4662330.jpg)
  * [Photo by MART  PRODUCTION: https://www.pexels.com/photo/woman-wearing-a-sports-bra-8032742/](notebooks/poses/pexels-mart-production-8032742.jpg)
  * [Photo by Elina Fairytale: https://www.pexels.com/photo/woman-in-pink-tank-top-and-blue-leggings-bending-her-body-3823074/](notebooks/poses/pexels-elina-fairytale-3823074.jpg)
  * [Photo by Cliff  Booth: https://www.pexels.com/photo/photo-of-woman-stretching-her-legs-4057525/](notebooks/poses/pexels-cliff-booth-4057525.jpg)
  * [Photo by Mikhail Nilov: https://www.pexels.com/photo/woman-standing-in-a-bending-position-on-a-box-6740089/](notebooks/poses/pexels-mikhail-nilov-6740089.jpg)
  * [Photo by cottonbro studio: https://www.pexels.com/photo/woman-in-black-sports-bra-and-black-panty-doing-yoga-4323290/](notebooks/poses/pexels-cottonbro-studio-4323290.jpg)
  * [Photo by ArtHouse Studio: https://www.pexels.com/photo/photo-of-man-bending-his-body-4334910/](notebooks/poses/pexels-arthouse-studio-4334910.jpg)
  * [Photo by Anna Shvets: https://www.pexels.com/photo/graceful-woman-performing-variation-of-setu-bandha-sarvangasana-yoga-pose-5012071/](notebooks/poses/pexels-anna-shvets-5012071.jpg)
  * [Photo by Miriam Alonso: https://www.pexels.com/photo/calm-young-asian-woman-doing-supine-hand-to-big-toe-yoga-asana-7593010/](notebooks/poses/pexels-miriam-alonso-7593010.jpg)
  * [Photo by Miriam Alonso: https://www.pexels.com/photo/anonymous-sportswoman-doing-stretching-exercise-during-yoga-session-7593002/](notebooks/poses/pexels-miriam-alonso-7593002.jpg)
  * [Photo by Miriam Alonso: https://www.pexels.com/photo/fit-young-asian-woman-preparing-for-handstand-during-yoga-training-at-home-7593004/](notebooks/poses/pexels-miriam-alonso-7593004.jpg)
  * [Photo by Anete Lusina: https://www.pexels.com/photo/concentrated-woman-standing-in-tree-pose-on-walkway-4793290/](notebooks/poses/pexels-anete-lusina-4793290.jpg)
  * [Photo by Miriam Alonso: https://www.pexels.com/photo/faceless-sportive-woman-stretching-back-near-wall-7592982/](notebooks/poses/pexels-miriam-alonso-7592982.jpg)


pkgId: 5fdeeb7c88128417785428329b863de05499dba0c66275024709f6681da8e610
name: python-aiqpy
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: Python bindings for connecting to a AIQ8 server
url: UNKNOWN
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiqpy-0.9.2-1.src.rpm
checksum_type: sha256
description:
  aiqpy is a wrapper library that allows you to interact with an `AppearIQ 8 <https://appeariq.com>`_ platform using Python.
  The library connects to the REST APIs of the platform and takes care of authentication and session management so you can focus on funnier things.


pkgId: e5ad1810e2cae4bc2a75f0cbaa00bbada407c32d2a828d829a1535cc73561252
name: python-air-db
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A data access layer for atmospheric time series datasets
url: https://github.com/isezen/air-db
rpm_license: AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-air-db-0.2.0-1.src.rpm
checksum_type: sha256
description:
  _air-db_ is a data access layer (DAL) to easily query atmospheric time series datasets from various sources. _air-db_ does not include any database. It is required to install corresponding database to work _air-db_ properly.

  To install sample database:

  ```python3
  from airdb import Database

  Database.install_sample()
  ```

  A database query can be implemented as follows:

  ```python3
  from airdb import Database

  db = Database('samp', return_type='df')

  q = db.query(param=['so2', 'pm10'], city='istanbul', date=['>2010-05-10', '<2012-10-07'], month=5)

  print(q)

  del db  # close connection to database

  ```

  and the output is:
  ```
        param      reg      city              sta                date     value
  0      pm10  marmara  istanbul      çatladıkapı 2010-05-10 00:00:00  0.798218
  1      pm10  marmara  istanbul      çatladıkapı 2010-05-10 01:00:00  0.946180
  2      pm10  marmara  istanbul      çatladıkapı 2010-05-10 02:00:00  0.884385
  3      pm10  marmara  istanbul      çatladıkapı 2010-05-10 03:00:00  0.537993
  4      pm10  marmara  istanbul      çatladıkapı 2010-05-10 04:00:00  0.136689
  ...     ...      ...       ...              ...                 ...       ...
  16123   so2  marmara  istanbul  şirinevler mthm 2012-05-31 19:00:00  0.697663
  16124   so2  marmara  istanbul  şirinevler mthm 2012-05-31 20:00:00  0.615755
  16125   so2  marmara  istanbul  şirinevler mthm 2012-05-31 21:00:00  0.489289
  16126   so2  marmara  istanbul  şirinevler mthm 2012-05-31 22:00:00  0.385102
  16127   so2  marmara  istanbul  şirinevler mthm 2012-05-31 23:00:00  0.039451

  [16128 rows x 6 columns]
  ```


pkgId: 3d94420496c3eaa3b8f6dce520944e20f395c88f5e916bab01c9096d5047ef2a
name: python-air-drf-relation
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Improved interaction with DRF relations.
url: https://github.com/bubaley/air-drf-relation
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-air-drf-relation-0.6.1-1.src.rpm
checksum_type: sha256
description:
  **AIR-DRF-RELATION**



  1. [Instalation](#instalation)
  2. [About](#about)
  3. [AirRelatedField](#airrelatedfield)
      1. [pk_only](#pk_only)
      2. [hidden](#hidden)
  4. [AirModelSerializer](#airmodelserializer)
      1. [user](#user)
      2. [extra_kwargs](#extra_kwargs)
      3. [hidden_fields](#hidden_fields)
      4. [Kwargs by actions](#kwargs-by-actions)
          1. [action_read_only_fields](#action_read_only_fields)
          2. [action_hidden_fields](#action_hidden_fields)
          3. [action_extra_kwargs](#action_extra_kwargs)
      4. [Priority extra_kwargs](#priority-extra_kwargs)
      5. [Filter nested querysets](#filter-nested-querysets)



  `$ pip install air-drf-relation`



  `air-drf-relation` adds flexibility and convenience in working with ModelSerializer.



  Used to extend the functionality of the `PrimaryKeyRelatedField`

  ```python
  class BookSerializer(ModelSerializer):
      
      author = AirRelatedField(AuthorSerializer)
      city = AirRelatedField(CitySerializer)

      class Meta:
          model = Book
          fields = ('uuid', 'name', 'author', 'city')
  ```

  `AirRelatedField` allows you to get not only pk but also an object with pk, which will be searched.
  ```json
  {
      "name": "demo",
      "author": {
          "id": 1
      },
      "city": 1
  }
  ```

  Automatically AirRelatedField returns a serialized object. If you only want to use pk, you must specify the `pk_only` key.

  ```python
  author = AirRelatedField(AuthorSerializer, pk_only=True)
  ```


  Hidden fields are not used for serialization and validation. The data will be returned without fields. Usually used together in `AirModelSerializer`

  ```python
  author = AirRelatedField(AuthorSerializer, hidden=True)
  ```


  You cannot use `hidden` and `pk_only` in ModelSerializer and with extra_kwargs



  Used to extend the functionality of the `ModelSerializer`

  ```python
  class BookSerializer(AirModelSerializer): # full example
      author = AirRelatedField(AuthorSerializer)
      city = AirRelatedField(AuthorSerializer)

      class Meta:
          model = Book
          fields = ('uuid', 'name', 'author', 'city')
          hidden_fields = ()
          read_only_fields = () # default read_only_fields
          extra_kwargs = {} # default extra_kwargs with support custom keys
          action_read_only_fields = {
              'create': {},
              '_': {} # used for other actions
          },
          action_hidden_fields = {
              'create': (),
              '_': ()
          }
          action_extra_kwargs = {
              'list': {},
              '_': {}
          }
          nested_save_fields = ()
  ```


  User is automatically put from the `request` if available. You can also set the user manually.

  ```python
  class DemoSerializer(AirModelSerializer):
      class Meta:
          fields = ('id', 'name')

      validate_name(self, value):
          if not self.user:
              return None
          return value
  ```
  Manually set user.
  ```python
  serializer = DemoSerializer(data={'name': 'demo'}, user=request.user)
  ```


  Extends the standard work with `extra_kwargs` by adding work with additional attributes. You can also transfer `extra_kwargs` manually.

  ```python
  class BookSerializer(AirModelSerializer):
      author = AirRelatedField(AuthorSerializer)

      class Meta:
          fields = ('id', 'name', 'author')
          extra_kwargs = {
              'author': {'pk_only': True},
              'name': {'hidden': True}
          }
  ```

  Hides fields for validation and seralization.
  ```python
  class BookSerializer(AirModelSerializer):
      class Meta:
          fields = ('id', 'name', 'author')
          hidden_fields = ('name', 'author')
  ```

  Kwargs by actions is used only when the event. You can pass acions separated by `,`.
  For events that don't match, you can use `_` key. It is used if action **is passed**.
  Action is set automatically from the ViewSet, or it can be passed manually.

  ```python
  class DemoViewSet(ModelViewSet):
      queryset = Demo.objects.all()
      serializer_class = DemoSerializer

      def perform_create(serializer, request):
          action = serializer.action # action is 'create'
          serializer.save()

      @action(methods=['POST'], detail=False)
      def demo_action(self, request):
          serializer = self.get_serializer_class()
          action = serializer.action # action is 'demo_action'
  ```

  Manually set action.
  ```python
  serializer = DemoSerializer(data={'name': 'demo'}, action='custom_action')
  action = serializer.action # action is 'custom_action'
  ```


  Sets `read_only_fields` by action in serializer.

  ```python
  class BookSerializer(AirModelSerializer):
      class Meta:
          fields = ('id', 'name', 'author')
          action_read_only_fields = {
              'create,update': ('name', 'author')
          }
  ```


  Sets `hidden_fields` by action in serializer.

  ```python
  class BookSerializer(AirModelSerializer):
      class Meta:
          fields = ('id', 'name', 'author')
          action_hidden_fields = {
              'custom_action': ('author', ),
              '_': ('id', )
          }
  ```


  Expand `extra_kwargs` by action in serializer.

  ```python
  class BookSerializer(AirModelSerializer):
      author = AirRelatedField(AuthorSerializer, pk_only=True, null=True)

      class Meta:
          fields = ('id', 'name', 'author')
          action_extra_kwargs = {
              'create,custom_update': {
                  'author': {'pk_only': False, 'null'=True}
              }
          }
  ```


  Below are the priorities of the extra_kwargs extension in ascending order
  1. extra_kwargs `in Meta`
  2. hidden_fields
  3. action_hidden_fields
  4. action_read_only_fields
  5. action_extra_kwargs
  6. extra_kwargs `manually transmitted`


  AirModelSerializer allows you to filter the queryset by nested fields.
  ```python
  class BookSerializer(AirModelSerializer):
      city = AirRelatedField(CitySerializer, queryset_function_name='custom_filter')

      def queryset_author(self, queryset):
          return queryset.filter(active=True, created_by=self.user)

      def filter_city_by_active(self, queryset):
          return queryset.filter(active=True)

      class Meta:
          model = Book
          fields = ('uuid', 'name', 'author', 'city')
  ```


pkgId: 202290be814b3701b4d780eb986cf12b9a4c6c28a26a12f8e65e6b6ae8e958d7
name: python-air-quality-index
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Download air quality index data from AirNow
url: https://palewi.re/docs/air-quality-index/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-air-quality-index-1.0.0-1.src.rpm
checksum_type: sha256
description:
  * Docs: [palewi.re/docs/air-quality-index/](https://palewi.re/docs/air-quality-index/)
  * Issues: [github.com/datadesk/air-quality-index/issues](https://github.com/datadesk/air-quality-index/issues)
  * Packaging: [pypi.python.org/pypi/air-quality-index](https://pypi.python.org/pypi/air-quality-index)
  * Testing: [github.com/datadesk/air-quality-index/actions](https://github.com/datadesk/air-quality-index/actions)


pkgId: d137fde748db27cb4ee744887c0aad963a452a17f4573ac59dde8746ee284464
name: python-air-sdk
arch: src
version: 2.15.0
epoch: 0
release: 1
summary: Python SDK for interacting with NVIDIA Air
url: https://github.com/NVIDIA/air_sdk/issues
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-air-sdk-2.15.0-1.src.rpm
checksum_type: sha256
description:
  This project provides a Python SDK for interacting with the NVIDIA Air API (https://air.nvidia.com/api/).

  [Click here for the full documentation](https://docs.nvidia.com/networking-ethernet-software/guides/nvidia-air/Air-Python-SDK/)



  The SDK requires python 3.8 or later. The safest way to install the SDK is to set up a virtual environment in python3.8:

  ```
  apt-get install python3.8
  ```

  ```
  python3.8 -m pip install virtualenv
  ```

  ```
  python3.8 -m virtualenv venv38
  ```

  ```
  . venv38/bin/activate
  ```



  To install the SDK, use pip:

  ```
  python3 -m pip install air-sdk
  ```



  ```
  >>> from air_sdk import AirApi
  >>> air = AirApi(username='<user>', password='<password>')
  ```



  Using the API requires the use of either an API token, a username/password, or a bearer token.



  To use an API token, one must first be generated. The easiest way to do this is via the [Air UI](https://air.nvidia.com/settings/api-tokens).

  Once a token is generated:

  ```
  >>> air = AirApi(username='<username>', password='<api_token>')
  ```



  To use a username/password, an administrator of NVIDIA Air must provision a service account. Once the administrator provides the username and password:

  ```
  >>> air = AirApi(username='<username>', password='<password>')
  ```



  Generally, it's recommended to use an [API Token](#api-token) over a bearer token. However, a bearer token might be used for testing or quick-and-dirty operations that might not need a long term API token. To use a bearer token, the calling user must have a nvidia.com account and have previously approved access for NVIDIA Air. Once a token is obtained:

  ```
  >>> air = AirApi(bearer_token='<bearer_token>')
  ```



  The SDK provides various helper methods for interacting with the API. For example:

  ```
  >>> air.simulations.list()
  [<Simulation sim1 c51b49b6-94a7-4c93-950c-e7fa4883591>, <Simulation sim2 3134711d-015e-49fb-a6ca-68248a8d4aff>]
  >>> sim1 = air.simulations.get('c51b49b6-94a7-4c93-950c-e7fa4883591')
  >>> sim1.title = 'My Sim'
  >>> sim1.store()
  ```



  Contributions to the SDK are very welcome. All code must pass linting and unit testing before it will be merged.



  ```
  python3 -m pip install .[dev]
  ```


  The Poetry virtual environment manager should be the preferred way to manage and install dependencies of the SDK. General information about Poetry can be found [here.](https://python-poetry.org/docs/)

  In order to use Poetry, you'll need to install poetry on your machine.
  If you're on a MacBook and have `brew` installed, you can easily accomplish this through the following:
  ```
  brew install poetry
  ```
  After Poetry is installed, you can install all dependencies for the project by running the following:
  ```
  poetry install --with dev
  ```



  ```
  ./unit_test.sh
  ```
  or
  ```
  pytest
  ```

  When using VSCode, tests can be easily launched and debugged using the `Testing` tab on the left sidebar.



  ```
  ruff check
  ```


  In this section, we delineate the usage of pre-commit hooks for this project.


  This section assumes that you've already accomplished the following:
  1. Cloned the codebase.
  2. Have a `.git` configuration file in your local environment (this is where pre-commit will "hook" into git commits).
  3. Created a python virtual environment.
  4. Activated your virtual environment.
  5. Installed all dependencies with `poetry install --with dev`

  If you don't know whether you have accomplished all of the above, try running `pre-commit --version` or `ruff --version` in your terminal at the source directory of the codebase.


  In order to use pre-commits, they need to be configured into your `.git` directory. This is accomplished by running the following in your terminal:
  ```
  >>> pre-commit install
  pre-commit installed at .git/hooks/pre-commit
  >>>
  ```
  And that's it! You should now have pre-commit hooks activated on your local environment.

  If you would like to uninstall your pre-commit hooks, run `pre-commit uninstall`.
  It's important to note that you should NOT run `python3 -m pip uninstall pre-commit` prior to uninstalling pre-commits from your `.git` directory, or else you might be blocked from making commits to your project.
  If this happens, re-install pre-commit with pip, run `pre-commit uninstall`, and then `python3 -m pip uninstall pre-commit`.



  Pre-commit hooks work with git to identify files which you've made changes to and then runs specific operations (such as linting or formatting) on those files.

  Currently, our primary hooks are performed by `ruff`, a Python linter and formatter. When attempting to git commit a code change is made that doesn't comply with the default `ruff` configuration and our custom configurations outlined in `.ruff.toml`, `ruff` will attempt to resolve the issue automatically by fixing small linting issues and re-formatting your code.

  In cases where the pre-commit hooks cannot safely correct your code, errors will be printed in your console which typically will provide links to the pieces of code you must address in order to successfully commit the code.

  In general, the development workflow is identical to what typically occurs when working on the codebase:
  1. Write/modify some code.
  2. Run `git add .`
  3. Run `git commit -m 'Your detailed commit message here.'`

  However, prior to successfully executing step 3 above, all pre-commits configured in `.pre-commit-config.yaml` are run.
  If the `ruff` formatting and linting both pass, your commit will be made. Otherwise, you will need to address the issues and re-add/commit your code.
  If the linter or formatter end up modifying your code, you will need to `git add .` these changes and commit them as well.



  We currently use the following hooks.


  Linting is the process of identifying and highlighting syntactical and stylistic trends and issues within code.
  This process helps developers identify and correct programming errors or unconventional coding practices.

  We use the ruff linter for our linting needs. This is configured in our `.pre-commit-config.yaml` here:
  ```

  repos:
      ...
      hooks:
      - id: ruff
          args: [ --fix ]
  ```
  We've included the `--fix` argument, which requests that `ruff` attempt to correct safely fixable issues without asking us ahead of time. Ruff also has an `--unsafe-fixes` flag that we could add to address fixes that are more risky to correct via automation, however we are not using that flag at this time.

  To manually run the linter, run `ruff --fix path/to/your/directory/file.py` or `ruff --fix path/to/your/directory`.

  If you would like to ignore a linting error on a specific piece of code, add a `# noqa: CODE_TO_IGNORE` tag next to the piece of code:
  ```
  def this_is_fully_linted(*args, **kwargs):
      ...

  def this_is_fully_linted_except_F841(*args, **kwargs):  # noqa: F841
      ...
  ```

  You can skip the linting of a specific code on entire files by adding `# ruff: noqa: CODE_TO_IGNORE` to the top of the file.
  ```


  def this_will_not_be_linted_for_F841(*args, **kwargs):
      ....

  def this_also_will_not_be_linted_for_F841(*args, **kwargs):
      ....
  ```

  To skip linting entirely for the entire folder, simply put `# ruff: noqa` at the top of the file.



  We use ruff for our code formatting needs.
  Formatting is the process of styling existing code so that it abides by a predetermined set of standards.
  This is important when working with large code-bases or when working with other developers since it makes large code-changes more uniform in style and easier to read.
  When code is more readable, it enables developers to identifying errors in their code logic more easily and helps other developers understand your implementation of features when they are reviewing your code.


  We use ruff for our code formatting needs. This is configured in our `.pre-commit-config.yaml`  here:
  ```

  repos:
      ...
      hooks:
      - id: ruff-format
  ```
  To manually format your code, run `ruff format path/to/your/directory/file.py` or `ruff format path/to/your/directory`.

  If you would like to suppress formatting on a section of code, you can wrap your code in `# fmt: off` and `# fmt: on`:
  ```

  def this_function_will_not_be_formatted(arg1,
      arg2,
      arg3, arg4,
  ):
      ...

  ```
  Alternatively, you can add `# fmt: skip` next to a body of code to supress formatting:
  ```
  class ThisClassIsFormatted:
      ...


  class ThisClassIsNotFormatted: # fmt: skip
      ...
  ```


  There is a `ruff` VS Code extension you may add to your IDE if you are using VS Code.
  Details on this extension can be found [here](https://github.com/astral-sh/ruff-vscode).

  We have already configured the ruff linter and formatter as suggested extensions for the project. They can be found in `.vcode/settings.json`.


pkgId: 755733804324f532c9dac7e8ec1ed6444e6c4b9fcc715d5111656bcd8cf8d358
name: python-air-sdk-python
arch: src
version: 0.19.8
epoch: 0
release: 1
summary: Python Client SDK Generated by Speakeasy
url: https://github.com/airventures/sdk-python.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-air-sdk-python-0.19.8-1.src.rpm
checksum_type: sha256
description:
  <div align="left">
      <a href="https://speakeasyapi.dev/"><img src="https://custom-icon-badges.demolab.com/badge/-Built%20By%20Speakeasy-212015?style=for-the-badge&logoColor=FBE331&logo=speakeasy&labelColor=545454" /></a>
      <a href="https://github.com/airventures/sdk-python.git/actions"><img src="https://img.shields.io/github/actions/workflow/status/speakeasy-sdks/bolt-php/speakeasy_sdk_generation.yml?style=for-the-badge" /></a>

  </div>

  <!-- Start Summary [summary] -->


  Air.ai API: Client API Documantation

  Some useful links:
  - [Temporal](https://temporal.io/)
  <!-- End Summary [summary] -->

  <!-- Start Table of Contents [toc] -->


  * [SDK Installation](https://github.com/airventures/sdk-python/blob/master/#sdk-installation)
  * [SDK Example Usage](https://github.com/airventures/sdk-python/blob/master/#sdk-example-usage)
  * [Available Resources and Operations](https://github.com/airventures/sdk-python/blob/master/#available-resources-and-operations)
  * [Error Handling](https://github.com/airventures/sdk-python/blob/master/#error-handling)
  * [Server Selection](https://github.com/airventures/sdk-python/blob/master/#server-selection)
  * [Custom HTTP Client](https://github.com/airventures/sdk-python/blob/master/#custom-http-client)
  * [Authentication](https://github.com/airventures/sdk-python/blob/master/#authentication)
  <!-- End Table of Contents [toc] -->

  <!-- Start SDK Installation [installation] -->


  The SDK can be installed using the *pip* package manager, with dependencies and metadata stored in the `setup.py` file.

  ```bash
  pip install air-sdk-python
  ```
  <!-- End SDK Installation [installation] -->

  <!-- Start SDK Example Usage [usage] -->




  ```python
  import air
  from air.models import shared

  s = air.Air(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )


  res = s.call.initiate_call(request=shared.Call(
      phone='874.397.6390 x76992',
      prompt_id=230621,
  ))

  if res.object is not None:
      
      pass

  ```
  <!-- End SDK Example Usage [usage] -->

  <!-- Start Available Resources and Operations [operations] -->


  <details open>
  <summary>Available methods</summary>




  * [initiate_call](https://github.com/airventures/sdk-python/blob/master/docs/sdks/call/README.md#initiate_call) - Initiate a call

  </details>
  <!-- End Available Resources and Operations [operations] -->







  <!-- Start Error Handling [errors] -->


  Handling errors in this SDK should largely match your expectations. All operations return a response object or raise an exception.

  By default, an API error will raise a errors.SDKError exception, which has the following properties:

  | Property        | Type             | Description           |
  |-----------------|------------------|-----------------------|
  | `.status_code`  | *int*            | The HTTP status code  |
  | `.message`      | *str*            | The error message     |
  | `.raw_response` | *httpx.Response* | The raw HTTP response |
  | `.body`         | *str*            | The response content  |

  When custom error responses are specified for an operation, the SDK may also raise their associated exception. You can refer to respective *Errors* tables in SDK docs for more details on possible exception types for each operation. For example, the `initiate_call` method may raise the following exceptions:

  | Error Type                                     | Status Code                                    | Content Type                                   |
  | ---------------------------------------------- | ---------------------------------------------- | ---------------------------------------------- |
  | errors.InitiateCallResponseBody                | 401                                            | application/json                               |
  | errors.InitiateCallCallResponseBody            | 403                                            | application/json                               |
  | errors.InitiateCallCallResponseResponseBody    | 404                                            | application/json                               |
  | errors.InitiateCallCallResponse422ResponseBody | 422                                            | application/json                               |
  | errors.InitiateCallCallResponse500ResponseBody | 500                                            | application/json                               |
  | errors.SDKError                                | 4XX, 5XX                                       | \*/\*                                          |



  ```python
  import air
  from air.models import errors, shared

  s = air.Air(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )

  res = None
  try:
      res = s.call.initiate_call(request=shared.Call(
      phone='874.397.6390 x76992',
      prompt_id=230621,
  ))

  except errors.InitiateCallResponseBody as e:
      
      raise(e)
  except errors.InitiateCallCallResponseBody as e:
      
      raise(e)
  except errors.InitiateCallCallResponseResponseBody as e:
      
      raise(e)
  except errors.InitiateCallCallResponse422ResponseBody as e:
      
      raise(e)
  except errors.InitiateCallCallResponse500ResponseBody as e:
      
      raise(e)
  except errors.SDKError as e:
      
      raise(e)

  if res.object is not None:
      
      pass

  ```
  <!-- End Error Handling [errors] -->



  <!-- Start Server Selection [server] -->




  You can override the default server globally by passing a server index to the `server_idx: int` optional parameter when initializing the SDK client instance. The selected server will then be used as the default on the operations that use it. This table lists the indexes associated with the available servers:

  | # | Server | Variables |
  | - | ------ | --------- |
  | 0 | `https://chat.air.ai/api/v1` | None |



  ```python
  import air
  from air.models import shared

  s = air.Air(
      server_idx=0,
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )


  res = s.call.initiate_call(request=shared.Call(
      phone='874.397.6390 x76992',
      prompt_id=230621,
  ))

  if res.object is not None:
      
      pass

  ```




  The default server can also be overridden globally by passing a URL to the `server_url: str` optional parameter when initializing the SDK client instance. For example:
  ```python
  import air
  from air.models import shared

  s = air.Air(
      server_url="https://chat.air.ai/api/v1",
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )


  res = s.call.initiate_call(request=shared.Call(
      phone='874.397.6390 x76992',
      prompt_id=230621,
  ))

  if res.object is not None:
      
      pass

  ```
  <!-- End Server Selection [server] -->



  <!-- Start Custom HTTP Client [http-client] -->


  The Python SDK makes API calls using the [requests](https://pypi.org/project/requests/) HTTP library.  In order to provide a convenient way to configure timeouts, cookies, proxies, custom headers, and other low-level configuration, you can initialize the SDK client with a custom `requests.Session` object.

  For example, you could specify a header for every request that this sdk makes as follows:
  ```python
  import air
  import requests

  http_client = requests.Session()
  http_client.headers.update({'x-custom-header': 'someValue'})
  s = air.Air(client=http_client)
  ```
  <!-- End Custom HTTP Client [http-client] -->



  <!-- Start Authentication [security] -->




  This SDK supports the following security scheme globally:

  | Name          | Type          | Scheme        |
  | ------------- | ------------- | ------------- |
  | `bearer_auth` | http          | HTTP Bearer   |

  To authenticate with the API the `bearer_auth` parameter must be set when initializing the SDK client instance. For example:
  ```python
  import air
  from air.models import shared

  s = air.Air(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )


  res = s.call.initiate_call(request=shared.Call(
      phone='874.397.6390 x76992',
      prompt_id=230621,
  ))

  if res.object is not None:
      
      pass

  ```
  <!-- End Authentication [security] -->

  <!-- Placeholder for Future Speakeasy SDK Sections -->





  This SDK is in beta, and there may be breaking changes between versions without a major version update. Therefore, we recommend pinning usage
  to a specific package version. This way, you can install the same version each time without breaking changes unless you are intentionally
  looking for the latest version.



  While we value open-source contributions to this SDK, this library is generated programmatically.
  Feel free to open a PR or a Github issue as a proof of concept and we'll do our best to include it in a future release!


pkgId: 6c426ef910975827b8183e5c416f41ed9be928e78c0dffc9cd4f69352028b89e
name: python-air2phin
arch: src
version: 0.0.21
epoch: 0
release: 1
summary: Air2phin is a tool for migrating Airflow DAGs to DolphinScheduler Python API.
url: https://github.com/WhaleOps/air2phin
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-air2phin-0.0.21-1.src.rpm
checksum_type: sha256
description:
  [![PyPi Version](https://img.shields.io/pypi/v/air2phin.svg?style=flat-square&logo=PyPi)](https://pypi.org/project/air2phin/)
  [![PyPi Python Versions](https://img.shields.io/pypi/pyversions/air2phin.svg?style=flat-square&logo=python)](https://pypi.org/project/air2phin/)
  [![PyPi License](https://img.shields.io/:license-Apache%202-blue.svg?style=flat-square)](https://raw.githubusercontent.com/WhaleOps/air2phin/main/LICENSE)
  [![PyPi Status](https://img.shields.io/pypi/status/air2phin.svg?style=flat-square)](https://pypi.org/project/air2phin/)
  [![Downloads](https://pepy.tech/badge/air2phin/month)](https://pepy.tech/project/air2phin)
  [![Coverage Status](https://img.shields.io/codecov/c/github/WhaleOps/air2phin/main.svg?style=flat-square)](https://codecov.io/github/WhaleOps/air2phin?branch=main) <!-- markdown-link-check-disable-line -->
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat-square&labelColor=ef8336)](https://pycqa.github.io/isort)
  [![CI](https://github.com/WhaleOps/air2phin/actions/workflows/ci.yaml/badge.svg)](https://github.com/WhaleOps/air2phin/actions/workflows/ci.yaml)
  [![Documentation Status](https://readthedocs.org/projects/air2phin/badge/?version=latest)](https://air2phin.readthedocs.io/en/latest/?badge=latest)

  air2phin is a tool for migrating Airflow DAGs to DolphinScheduler Python API.



  For now, it just for test and without publish to pypi but will be adding in the future.
  You could still install locally by yourself.

  ```shell
  python -m pip install --upgrade air2phin
  ```



  Here will give a quick example to show how to migrate base on standard input.

  ```shell


  air2phin test "from airflow.operators.bash import BashOperator

  test = BashOperator(
      task_id='test',
      bash_command='echo 1',
  )
  "
  ```

  And you will see the migrated result in the standard output. air2phin can only migrate standard input, it can
  also migrate file, directory and even can use in your python code. For more detail, please see [our usage](https://air2phin.readthedocs.io/en/latest/start.html#usage).



  The documentation host on read the doc and is available at [https://air2phin.readthedocs.io](https://air2phin.readthedocs.io).



  For now, we support following statement from Airflow's DAG files



  | Before Migration             | After Migration                                                            |
  |------------------------------|----------------------------------------------------------------------------|
  | `from airflow import DAG`    | `from pydolphinscheduler.core.process_definition import ProcessDefinition` |
  | `with DAG(...) as dag: pass` | `with ProcessDefinition(...) as dag: pass`                                 |





  | Before Migration                                             | After Migration                                               |
  |--------------------------------------------------------------|---------------------------------------------------------------|
  | `from airflow.operators.dummy_operator import DummyOperator` | `from pydolphinscheduler.tasks.shell import Shell`            |
  | `from airflow.operators.dummy import DummyOperator`          | `from pydolphinscheduler.tasks.shell import Shell`            |
  | `dummy = DummyOperator(...)`                                 | `dummy = Shell(..., command="echo 'airflow dummy operator'")` |



  | Before Migration                                  | After Migration                                    |
  |---------------------------------------------------|----------------------------------------------------|
  | `from airflow.operators.bash import BashOperator` | `from pydolphinscheduler.tasks.shell import Shell` |
  | `bash = BashOperator(...)`                        | `bash = Shell(...)`                                |



  | Before Migration                                                    | After Migration                                |
  |---------------------------------------------------------------------|------------------------------------------------|
  | `from airflow.operators.spark_sql_operator import SparkSqlOperator` | `from pydolphinscheduler.tasks.sql import Sql` |
  | `spark = SparkSqlOperator(...)`                                     | `spark = Sql(...)`                             |



  | Before Migration                                               | After Migration                                      |
  |----------------------------------------------------------------|------------------------------------------------------|
  | `from airflow.operators.python_operator import PythonOperator` | `from pydolphinscheduler.tasks.python import Python` |
  | `python = PythonOperator(...)`                                 | `python = Python(...)`                               |


pkgId: 9c0b8dd6cd1acc2fbc6f2c793a00f4e195292101a26f6ca20394539947133682
name: python-air2waterpy
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: A python pacakge for running the air2water model
url: https://github.com/he134543/air2waterpy
rpm_license: MIT-License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-air2waterpy-0.0.2-1.src.rpm
checksum_type: sha256
description:
  A python pacakge implementing an air2water model. Numba is used to speed up the computation. Parrallel computing is included for the calibration process. For detailed examples, check our Github repository: https://github.com/he134543/air2waterpy


pkgId: ed2bed2f3a5d4625d050568b3382a407f8e896662f4598f7c1fd60e786b275bd
name: python-airavata-python-sdk-test
arch: src
version: 0.0.1.post2
epoch: 0
release: 1
summary: Apache Airavata Python SDK
url: https://pypi.org/project/airavata-python-sdk-test/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airavata-python-sdk-test-0.0.1.post2-1.src.rpm
checksum_type: sha256
description:
  The Apache Airavata Python SDK for  third party clients to  integrate with Airavata middleware




   - airavata

      Includes thrift stubs generated by a thrift compiler. Mainly contains data model and functions. You may
                need to import data model packages to integrate with clients.

   - airavata_sdk
      - clients

          Includes integration clients, which you want to import and integrate with your code to access airavata middleware.

      - samples

          Includes set of sample implementation of  integration clients to demonastrate the integration with  airavata middleware

      - transport

          Includes connection handling classes and connection pool implementations




    -  Create a virtual environment

         ```
         python3 -m venv venv
          ```
    -  Activate the virtual environment

         ```
         source venv/bin/activate
         ```
    -  Install dependencies

         ```
         pip install -r requirements.txt
         ```
    -  Create a INI file containing server configuration details. For more information refer to default settings file

         [settings.ini](airavata_sdk/transport/settings.ini)



     You can generate *.tar.gz or .whl distribution and install to any external project.

     - Make sure you have the latest versions of setuptools and wheel installed

         ```
         python3 -m pip install --user --upgrade setuptools wheel
         ```
     - Now run this command from the same directory where setup.py is located

          ```
          python3 setup.py sdist bdist_wheel
          ```
     - This command should output a lot of text and once completed should generate two files in the dist directory

          ```
          dist/
              airavata_python_sdk-1.0.0-py2.py3-none-any.whl
              airavata-python-sdk-1.0.0.tar.gz
          ```

  You should be able to install those packages into your project.





     - [api_server_client](airavata_sdk/clients/api_server_client.py)
        - is_user_exists(authz_token, gateway_id, user_name)
        - add_gateway( authz_token, [gateway](airavata/model/workspace/ttypes.py))
        - get_all_users_in_gateway( authz_token, gateway_id)
        - update_gateway( authz_token, gateway_id, updated_gateway)
        - get_gateway( authz_token, gateway_id)
        - delete_gateway( authz_token, gateway_id)
        - get_all_gateways( authz_token)
        - is_gateway_exist( authz_token, gateway_id)
        - create_notification( authz_token, [notification](airavata/model/workspace/ttypes.py))
        - update_notification( authz_token, notification)
        - delete_notification( authz_token, gateway_id, notification_id)
        - get_notification( authz_token, gateway_id, notification_id)
        - get_all_notifications( authz_token, gateway_id)
        - generate_and_register_ssh_keys( authz_token, description)
        - register_pwd_credential( authz_token, login_user_name, password, description)
        - delete_ssh_pub_key( authz_token, airavata_cred_store_token)
        - delete_pwd_credential( authz_token, airavata_cred_store_token)
        - create_project( authz_token, gateway_id, [project](airavata/model/workspace/ttypes.py))
        - update_project( authz_token, project_id, updated_project)
        - get_project( authz_token, project_id)
        - delete_project( authz_token, project_id)
        - get_user_projects( authz_token, gateway_id, user_name, limit, offset)
        - search_projects( authz_token, gateway_id, user_name, filters, limit, offset)
        - search_experiments( authz_token, gateway_id, user_name, filters, limit, offset)
        - get_experiment_statistics( authz_token, gateway_id, from_time, to_time, user_name, application_name,
                                    resource_host_name)
        - get_experiments_in_project( authz_token, project_id, limit, offset)
        - get_user_experiments( authz_token, gateway_id, user_name, limit, offset)
        - create_experiment( authz_token, gateway_id, [experiment](airavata/model/experiment/ttypes.py))
        - delete_experiment( authz_token, experiment_id)
        - get_experiment( authz_token, airavata_experiment_id)
        - get_experiment_by_admin( authz_token, airavata_experiment_id)
        - get_detailed_experiment_tree( authz_token, airavata_experiment_id)
        - update_experiment( authz_token, airavata_experiment_id, experiment)
        - update_experiment_configuration( authz_token, airavata_experiment_id, [user_configuration](airavata/model/experiment/ttypes.py))
        - update_resource_scheduling( authz_token, airavata_experiment_id, [resource_scheduling](airavata/model/scheduling/ttypes.py))
        - validate_experiment( authz_token, airavata_experiment_id)
        - launch_experiment( authz_token, airavata_experiment_id, gateway_id)
        - get_experiment_status( authz_token, airavata_experiment_id)
        - get_experiment_outputs( authz_token, airavata_experiment_id)
        - get_intermediate_outputs( authz_token, airavata_experiment_id)
        - get_job_statuses( authz_token, airavata_experiment_id)
        - get_job_details( authz_token, airavata_experiment_id)
        - clone_experiment( authz_token, existing_experiment_id, new_experiment_name, new_experiment_projectId)
        - clone_experiment_by_admin( authz_token, existing_experiment_id, new_experiment_name)
        - terminate_experiment( authz_token, airavata_experiment_id, gateway_id)
        - register_application_module( authz_token, gateway_id, application_module)
        - get_application_module( authz_token, app_module_id)
        - update_application_module( authz_token, app_module_id, [application_module](airavata/model/appcatalog/appdeployment/ttypes.py))
        - get_all_app_modules( authz_token, gateway_id)
        - get_accessible_app_modules( authz_token, gateway_id)
        - delete_application_module( authz_token, app_module_id)
        - register_application_deployment( authz_token, gateway_id, [application_deployment](airavata/model/appcatalog/appdeployment/ttypes.py))
        - get_application_deployment( authz_token, app_deployment_id)
        - update_application_deployment( authz_token, app_deployment_id, application_deployment)
        - delete_application_deployment( authz_token, app_deployment_id)
        - get_all_application_deployments( authz_token, gateway_id):
        - get_accessible_application_deployments( authz_token, gateway_id, [permission_type](airavata/model/sharing/ttypes.py))
        - get_app_module_deployed_resources( authz_token, app_module_id)
        - get_application_deployments_for_app_module_and_group_resource_profile( authz_token, app_module_id,
                                                                                group_resource_profileId)
        - register_application_interface( authz_token, gateway_id, [application_interface](airavata/model/appcatalog/appinterface/ttypes.py))
        - clone_application_interface( authz_token, existing_app_interface_id, new_application_name, gateway_id)
        - get_application_interface( authz_token, app_interface_id)
        - update_application_interface( authz_token, app_interface_id, application_interface)
        - delete_application_interface( authz_token, app_interface_id)
        - get_all_application_interface_names( authz_token, gateway_id)
        - get_all_application_interfaces( authz_token, gateway_id)
        - get_application_inputs( authz_token, app_interface_id)
        - get_application_outputs( authz_token, app_interface_id)
        - get_available_app_interface_compute_resources( authz_token, app_interface_id)
        - register_compute_resource( authz_token, [compute_resource_description](airavata/model/appcatalog/computeresource/ttypes.py))
        - get_compute_resource( authz_token, compute_resource_id)
        - get_all_compute_resource_names( authz_token)
        - update_compute_resource( authz_token, compute_resource_id, compute_resource_description)
        - delete_compute_resource( authz_token, compute_resource_id)
        - register_storage_resource( authz_token, [storage_resource_description](airavata/model/appcatalog/storageresource/ttypes.py))
        - get_storage_resource( authz_token, storage_resource_id)
        - get_all_storage_resource_names( authz_token)
        - update_storage_resource( authz_token, storage_resource_id, storage_resource_description)
        - delete_storage_resource( authz_token, storage_resource_id)
        - add_local_submission_details( authz_token, compute_resource_id, priority_order, [local_submission](airavata/model/appcatalog/computeresource/ttypes.py))
        - update_local_submission_details( authz_token, job_submission_interface_id, local_submission)
        - get_local_job_submission( authz_token, job_submission_id)
        - add_ssh_job_submission_details( authz_token, compute_resource_id, priority_order, [ssh_job_submission](airavata/model/appcatalog/computeresource/ttypes.py))
        - add_ssh_fork_job_submission_details( authz_token, compute_resource_id, priority_order, ssh_job_submission)
        - get_ssh_job_submission( authz_token, job_submission_id)
        - get_unicore_job_submission( authz_token, job_submission_id)
        - add_cloud_job_submission_details( authz_token, compute_resource_id, priority_order, [cloud_submission](airavata/model/appcatalog/computeresource/ttypes.py))
        - get_cloud_job_submission( authz_token, job_submission_id)
        - update_ssh_job_submission_details( authz_token, job_submission_interface_id, [ssh_job_submission](airavata/model/appcatalog/computeresource/ttypes.py))
        - update_cloud_job_submission_details( authz_token, job_submission_interface_id, ssh_job_submission)
        - update_unicore_job_submission_details( authz_token, job_submission_interface_id, [unicore_job_submission](airavata/model/appcatalog/computeresource/ttypes.py))
        - add_local_data_movement_details( authz_token, product_uri, data_move_type, priority_order,
                                          [local_data_movement](airavata/model/data/movement/ttypes.py))
        - update_local_data_movement_details( authz_token, data_movementInterface_id, local_data_movement)
        - get_local_data_movement( authz_token, data_movement_id)
        - add_scp_data_movement_details( authz_token, product_uri, data_move_type, priority_order,[scp_data_movement](airavata/model/data/movement/ttypes.py))
        - update_scp_data_movement_details( authz_token, data_movement_interface_id, scp_data_movement)
        - get_scp_data_movement( authz_token, data_movement_id)
        - add_unicore_data_movement_details( authz_token, product_uri, data_move_type, priority_order,
        - update_unicore_data_movement_details( authz_token, data_movement_interface_id, unicore_data_movement)
        - get_unicore_data_movement( authz_token, data_movement_id)
        - add_grid_ftp_data_movement_details( authz_token, product_uri, data_move_type, priority_order,
                                             grid_ftp_data_movement)
        - update_grid_ftp_data_movement_details( authz_token, data_movement_interface_id, grid_ftp_data_movement)
        - get_grid_ftp_data_movement( authz_token, data_movement_id)
        - change_job_submission_priority( authz_token, job_submission_interface_id, new_priority_order)
        - change_data_movement_priority( authz_token, data_movement_interface_id, new_priority_order)
        - change_job_submission_priorities( authz_token, job_submission_priority_map)
        - change_data_movement_priorities( authz_token, data_movement_priority_map)
        - delete_job_submission_interface( authz_token, compute_resource_id, [job_submission_interface_id](airavata/model/appcatalog/computeresource/ttypes.py))
        - delete_data_movement_interface( authz_token, product_uri, data_movement_interface_id, data_move_type)
        - register_resource_job_manager( authz_token, [resource_job_manager](airavata/model/appcatalog/computeresource/ttypes.py))
        - update_resource_job_manager( authz_token, resource_job_manager_id, updated_resource_job_manager)
        - get_resource_job_manager( authz_token, resource_job_manager_id)
        - delete_resource_job_manager( authz_token, resource_job_manager_id)
        - delete_batch_queue( authz_token, compute_resource_id, queue_name)
        - register_gateway_resource_profile( authz_token, gateway_resource_profile)
        - get_gateway_resource_profile( authz_token, gateway_id)
        - update_gateway_resource_profile( authz_token, gateway_id, gateway_resource_profile)
        - delete_gateway_resource_profile( authz_token, gateway_id)
        - add_gateway_compute_resource_preference( authz_token, gateway_id, compute_resource_id,
                                                  compute_resource_preferance)
        - add_gateway_storage_preference( authz_token, gateway_id, storage_resource_id, storage_preference)
        - get_gateway_compute_resource_preference( authz_token, gateway_id, compute_resource_id)
        - get_gateway_storage_preference( authz_token, gateway_id, storage_resourceId)
        - get_all_gateway_compute_resource_preferences( authz_token, gateway_id)
        - get_all_gateway_storage_preferences( authz_token, gateway_id)
        - get_all_gateway_resource_profiles( authz_token)
        - update_gateway_compute_resource_preference( authz_token, gateway_id, compute_resource_id,
                                                     compute_resource_preference)
        - update_gateway_storage_preference( authz_token, gateway_id, storage_id, [storage_preference](airavata/model/appcatalog/gatewayprofile/ttypes.py))
        - delete_gateway_compute_resource_preference( authz_token, gateway_id, compute_resource_id)
        - delete_gateway_storage_preference( authz_token, gateway_id, storage_id)
        - get_ssh_account_provisioners( authz_token)
        - does_user_have_ssh_account( authz_token, compute_resource_id, user_id)
        - is_ssh_setup_complete_for_user_compute_resource_preference( authz_token, compute_resource_id,
                                                                     airavata_cred_store_token):
        - setup_user_compute_resource_preferences_for_ssh( authz_token, compute_resource_id, user_id,
                                                          airavata_cred_store_token)
        - register_user_resource_profile( authz_token, user_resource_profile)
        - is_user_resource_profile_exists( authz_token, user_id, gateway_id)
        - get_user_resource_profile( authz_token, user_id, gateway_id)
        - update_user_resource_profile( authz_token, user_id, gateway_id, user_resource_profile):
        - delete_user_resource_profile( authz_token, user_id, gateway_id)
        - add_user_compute_resource_preference( authz_token, user_id, gateway_id, user_compute_resource_id,
                                               user_compute_resource_preference)
        - add_user_storage_preference( authz_token, user_id, gateway_id, user_storage_resource_id,
                                      user_storage_preference)
        - get_user_compute_resource_preference( authz_token, user_id, gateway_id, user_compute_resource_id):
        - get_user_storage_preference( authz_token, user_id, gateway_id, user_storage_resource_id)
        - get_all_user_compute_resource_preferences( authz_token, user_id, gateway_id)
        - get_all_user_storage_preferences( authz_token, user_id, gateway_id)
        - get_all_user_resource_profiles( authz_token)
        - update_user_compute_resource_preference( authz_token, user_id, gateway_id, user_compute_resourceId,
                                                  user_compute_resource_preference)
        - update_user_storage_preference( authz_token, user_id, gateway_id, user_storage_id,
                                         user_storage_preference)
        - delete_user_compute_resource_preference( authz_token, user_id, gateway_id, user_compute_resource_id)
        - delete_user_storage_preference( authz_token, user_id, gateway_id, user_storage_id)
        - get_latest_queue_statuses( authz_token)
        - register_data_product( authz_token, [data_product_model](airavata/model/data/replica/ttypes.py))
        - get_data_product( authz_token, data_product_uri)
        - register_replica_location( authz_token, [replica_location_model](airavata/model/data/replica/ttypes.py))
        - get_parent_data_product( authz_token, product_uri)
        - get_child_data_products( authz_token, product_uri)
        - share_resource_with_users( authz_token, resource_id, user_permission_list)
        - share_resource_with_groups( authz_token, resource_id, group_permission_list)
        - revoke_sharing_of_resource_from_users( authz_token, resource_id, user_permission_list)
        - revoke_sharing_of_resource_from_groups( authz_token, resource_id, group_permission_list)
        - get_all_accessible_users( authz_token, resource_id, permission_type)
        - get_all_accessible_groups( authz_token, resource_id, permission_type)
        - get_all_directly_accessible_users( authz_token, resource_id, permission_type)
        - get_all_directly_accessible_groups( authz_token, resource_id, permission_type)
        - user_has_access( authz_token, resource_id, [permission_type](airavata/model/sharing/ttypes.py))
        - create_group_resource_profile( authz_token, group_resource_profile)
        - update_group_resource_profile( authz_token, group_resource_profile)
        - get_group_resource_profile( authz_token, group_resource_profile_id)
        - remove_group_resource_profile( authz_token, group_resource_profile_id)
        - get_group_resource_list( authz_token, gateway_id)
        - remove_group_compute_prefs( authz_token, compute_resource_id, group_resource_profile_id)
        - remove_group_compute_resource_policy( authz_token, resource_policy_id)
        - remove_group_batch_queue_resource_policy( authz_token, resource_policy_id)
        - get_group_compute_resource_preference( authz_token, compute_resource_id, group_resource_profile_id)
        - get_group_compute_resource_policy( authz_token, resource_policy_id)
        - get_batch_queue_resource_policy( authz_token, resource_policy_id)
        - get_group_compute_resource_pref_list( authz_token, group_resource_profile_id)
        - get_group_batch_queue_resource_policy_list( authz_token, group_resource_profile_id)
        - get_group_compute_resource_policy_list( authz_token, group_resource_profile_id)
        - get_gateway_groups( authz_token)
        - get_parser( authz_token, parser_id, gateway_id)
        - save_parser( authz_token, parser)
        - list_all_parsers( authz_token, gateway_id)
        - remove_parser( authz_token, parser_id, gateway_id)
        - get_parsing_template( authz_token, template_id, gateway_id)
        - get_parsing_templates_for_experiment( authz_token, experiment_id, gateway_id)
        - save_parsing_template( authz_token, parsing_template)
        - remove_parsing_template( authz_token, template_id, gateway_id)
        - list_all_parsing_templates( authz_token, gateway_id)

     Sample implementations can be found at [api_server_client_samples](airavata_sdk/samples/api_server_client_samples.py)

     -  [group_manager_client](airavata_sdk/clients/group_manager_client.py)

        - create_group( authz_token, [group_model](airavata/model/group/ttypes.py))
        - update_group( authz_token, group_model)
        - delete_group( authz_token, group_id, owner_id)
        - get_group( authz_token, group_id)
        - get_groups( authz_token)
        - get_all_groups_user_belongs( authz_token, user_name)
        - add_users_to_group( authz_token, user_ids, group_id)
        - remove_users_from_group( authz_token, user_ids, group_id)
        - transfer_group_ownership( authz_token, group_id, new_owner_id)
        - add_group_admins( authz_token, group_id, admin_ids)
        - remove_group_admins( authz_token, group_id, admin_ids)
        - has_admin_access( authz_token, group_id, admin_id)
        - has_owner_access( authz_token, group_id, owner_id)

     Sample implementations can be found at [group_manager_client_samples](airavata_sdk/samples/group_manager_client_samples.py)

     -   [iam_admin_client](airavata_sdk/clients/iam_admin_client.py)

         - set_up_gateway( authz_token, gateway)
         - is_username_available( authz_token, username)
         - register_user( authz_token, username, email_address, first_name, last_name, new_password)
         - enable_user( authz_token, username)
         - is_user_enabled( authz_token, username)
         - is_user_exist( authz_token, username)
         - get_user( authz_token, username)
         - get_users( authz_token, offset, limit, search)
         - reset_user_password( authz_token, username, new_password)
         - find_users( authz_token, email, user_id)
         - update_user_profile( authz_token, user_details)
         - delete_user( authz_token, username)
         - add_role_to_user( authz_token, username, role_name)
         - remove_role_from_user( authz_token, username, role_name)
         -  get_users_with_role( authz_token, role_name)

     Sample implementations can be found at [iam_admin_client_samples](airavata_sdk/samples/iam_admin_client_samples.py)


     - [sharing_registry_client](airavata_sdk/clients/sharing_registry_client.py)

         - create_domain([domain](airavata/model/sharing/ttypes.py))
         - update_domain( domain)
         - is_domain_exists( domain_id)
         - delete_domain( domain_id)
         - get_domain( domain_id)
         - get_domains( offset, limit)
         - create_user( user)
         - updated_user( user)
         - is_user_exists( domain_id, user_id)
         - delete_user( domain_id, user_id)
         - get_user( domain_id, user_id)
         - get_users( domain_id, offset, limit)
         - is_group_exists( domain_id, group_id)
         - delete_group( domain_id, group_id)
         - get_group( domain_id, group_id)
         - get_groups( domain_id, offset, limit)
         - add_users_to_group( domain_id, user_ids, group_id)
         - remove_users_from_group( domain_id, user_ids, group_id)
         - transfer_group_ownership( domain_id, group_id, new_owner_id)
         - add_group_admins( domain_id, group_id, admin_ids)
         - remove_group_admins( domain_id, group_id, admin_ids)
         - has_admin_access( domain_id, group_id, admin_id)
         - has_owner_access( domain_id, group_id, owner_id)
         - get_group_members_of_type_user( domain_id, group_id, offset, limit)
         - get_group_members_of_type_group( domain_id, group_id, offset, limit)
         - add_child_groups_to_parent_group( domain_id, child_ids, group_id)
         - remove_child_group_from_parent_group( domain_id, child_id, group_id)
         - get_all_member_groups_for_user( domain_id, user_id)
         - create_entity_type( entity_type)
         - update_entity_type( entity_type)
         - is_entity_type_exists( domain_id, entity_type_id)
         - delete_entity_type( domain_id, entity_type_id)
         - get_entity_type( domain_id, entity_type_id)
         - get_entity_types( domain_id, offset, limit)
         - create_entity( [entity](airavata/model/sharing/ttypes.py))
         - update_entity( entity)
         - is_entity_exists( domain_id, entity_id)
         - delete_entity( domain_id, entity_id)
         - get_entity( domain_id, entity_id)
         - search_entities( domain_id, user_id, filters, offset, limit)
         - get_list_of_shared_users( domain_id, entity_id, permission_type_id)
         - get_list_of_directly_shared_users( domain_id, entity_id, permission_type_id)
         - get_list_of_shared_groups( domain_id, entity_id, permission_type_id)
         - get_list_of_directly_shared_groups( domain_id, entity_id, permission_type_id)
         - create_permission_type( permission_type)
         - update_permission_type( permission_type)
         - is_permission_exists( domain_id, permission_id)
         - delete_permission_type( domain_id, permission_type_id)
         - get_permission_type( domain_id, permission_type_id)
         - get_permission_types( domain_id, offset, limit)
         - share_entity_with_users( domain_id, entity_id, user_list, permission_type_id, cascade_permission)
         - revoke_entity_sharing_from_users( domain_id, entity_id, user_list, permission_type_id)
         - share_entity_with_groups( domain_id, entity_id, group_list, permission_type_id, cascade_permission)
         - revoke_entity_sharing_from_groups( domain_id, entity_id, group_list, permission_type_id)
         - user_has_access( domain_id, user_id, entity_id, permission_type_id)

     Sample implementations can be found at [sharing_registry_client_samples](airavata_sdk/samples/sharing_registry_client_samples.py)



     - [tenant_profile_client](airavata_sdk/clients/tenant_profile_client.py)

         - add_gateway( authz_token, gateway)
         - update_gateway( authz_token, updated_gateway)
         - get_gateway( authz_token, airavata_internal_gateway_id)
         - delete_gateway( authz_token, airavata_internal_gateway_id, gateway_id)
         - get_all_gateways( authz_token)
         - is_gateway_exist( authz_token, gateway_id)
         - get_all_gateways_for_user( authz_token, requester_username)

     Sample implementations can be found at [tenant_profile_client_samples](airavata_sdk/samples/tenant_profile_client_samples.py)


     - [user_profile_client](airavata_sdk/clients/user_profile_client.py)

         - initialize_user_profile( authz_token)
         - add_user_profile( authz_token, [user_profile](airavata/model/user/ttypes.py))
         - update_user_profile( authz_token, user_profile)
         -  get_user_profile_by_id( authz_token, user_id, gateway_id)
         - delete_user_profile( authz_token, user_id, gateway_id)
         - get_all_user_profiles_in_gateway( authz_token, gateway_id, offset, limit)
         - does_user_exist( authz_token, user_id, gateway_id)

     Sample implementations can be found at [user_profile_client_samples](airavata_sdk/samples/user_profile_client_samples.py)


pkgId: 0ff1a41db38a6fbcc62373afd7980e08ca9e52fd48f42e1e1dffccba11968f82
name: python-airbase
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: An easy downloader for the AirBase air quality data.
url: https://github.com/johnpaton/airbase
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbase-0.8.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/airbase.svg)](https://badge.fury.io/py/airbase)
  [![Downloads](https://pepy.tech/badge/airbase)](https://pepy.tech/project/airbase)
  [![CI/CD](https://github.com/JohnPaton/airbase/actions/workflows/cicd.yaml/badge.svg?branch=master)](https://github.com/JohnPaton/airbase/actions/workflows/cicd.yaml)
  [![Documentation Status](https://readthedocs.org/projects/airbase/badge/?version=latest)](https://airbase.readthedocs.io/en/latest/?badge=latest)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![Code style: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/format.json)](https://github.com/astral-sh/ruff)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)



  An easy downloader for the AirBase air quality data.

  AirBase is an air quality database provided by the European Environment Agency
  (EEA). The data is available for download at
  [the portal](http://discomap.eea.europa.eu/map/fme/AirQualityExport.htm), but
  the interface makes it a bit time consuming to do bulk downloads. Hence, an easy
  Python-based interface.

  Read the full documentation at https://airbase.readthedocs.io.



  To install `airbase`, simply run

  ```bash
  $ pip install airbase
  ```



  🗺 Get info about available countries and pollutants:

  ```pycon
  >>> import airbase
  >>> client = airbase.AirbaseClient()
  >>> client.all_countries
  ['GR', 'ES', 'IS', 'CY', 'NL', 'AT', 'LV', 'BE', 'CH', 'EE', 'FR', 'DE', ...

  >>> client.all_pollutants
  {'k': 412, 'CO': 10, 'NO': 38, 'O3': 7, 'As': 2018, 'Cd': 2014, ...

  >>> client.pollutants_per_country
  {'AD': [{'pl': 'CO', 'shortpl': 10}, {'pl': 'NO', 'shortpl': 38}, ...

  >>> client.search_pollutant("O3")
  [{'pl': 'O3', 'shortpl': 7}, {'pl': 'NO3', 'shortpl': 46}, ...
  ```

  🗂 Request download links from the server and save the resulting CSVs into a directory:

  ```pycon
  >>> r = client.request(country=["NL", "DE"], pl="NO3", year_from=2015)
  >>> r.download_to_directory(dir="data", skip_existing=True)
  Generating CSV download links...
  100%|██████████| 2/2 [00:03<00:00,  2.03s/it]
  Generated 12 CSV links ready for downloading
  Downloading CSVs to data...
  100%|██████████| 12/12 [00:01<00:00,  8.44it/s]
  ```

  💾 Or concatenate them into one big file:

  ```pycon
  >>> r = client.request(country="FR", pl=["O3", "PM10"], year_to=2014)
  >>> r.download_to_file("data/raw.csv")
  Generating CSV download links...
  100%|██████████| 2/2 [00:12<00:00,  7.40s/it]
  Generated 2,029 CSV links ready for downloading
  Writing data to data/raw.csv...
  100%|██████████| 2029/2029 [31:23<00:00,  1.04it/s]
  ```

  📦 Download the entire dataset (not for the faint of heart):

  ```pycon
  >>> r = client.request()
  >>> r.download_to_directory("data")
  Generating CSV download links...
  100%|██████████| 40/40 [03:38<00:00,  2.29s/it]
  Generated 146,993 CSV links ready for downloading
  Downloading CSVs to data...
    0%|          | 299/146993 [01:50<17:15:06,  2.36it/s]
  ```

  🌡 Don't forget to get the metadata about the measurement stations:

  ```pycon
  >>> client.download_metadata("data/metadata.tsv")
  Writing metadata to data/metadata.tsv...
  ```



  ``` console
  $ airbase download --help
  Usage: airbase download [OPTIONS]
    Download all pollutants for all countries

    The -c/--country and -p/--pollutant allow to specify which data to download, e.g.
    - download only Norwegian, Danish and Finish sites
      airbase download -c NO -c DK -c FI
    - download only SO2, PM10 and PM2.5 observations
      airbase download -p SO2 -p PM10 -p PM2.5

  Options:
    -c, --country [AD|AL|AT|...]
    -p, --pollutant [k|CO|NO|...]
    --path PATH                     [default: data]
    --year INTEGER                  [default: 2022]
    -O, --overwrite                 Re-download existing files.
    -q, --quiet                     No progress-bar.
    --help                          Show this message and exit.
  ```



  * ~~Parallel CSV downloads~~ Contributed by @avaldebe
  * ~~CLI to avoid using Python all together~~ Contributed by @avaldebe
  * Data wrangling module for AirBase output data


pkgId: 1fc97339d32f64d378b1ebbda073761d424f962a82be14e727ae9d08a9078234
name: python-airbnb
arch: src
version: 2.3.2
epoch: 0
release: 1
summary: A wrapper for airbnb.com API
url: https://github.com/nderkach/airbnb-python
rpm_license: DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE Version 2, December 2004
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbnb-2.3.2-1.src.rpm
checksum_type: sha256
description:
   Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>

   Everyone is permitted to copy and distribute verbatim or modified
   copies of this license document, and changing it is allowed as long
   as the name is changed.

              DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

    0. You just DO WHAT THE FUCK YOU WANT TO.
  Description: UNKNOWN
  Platform: UNKNOWN
  Classifier: Programming Language :: Python
  Classifier: Topic :: Software Development :: Libraries :: Python Modules
  Classifier: Development Status :: 4 - Beta
  Classifier: Intended Audience :: Developers
  Classifier: Intended Audience :: End Users/Desktop
  Classifier: Operating System :: OS Independent
  Classifier: License :: Public Domain
  Classifier: Programming Language :: Python :: 3
  Classifier: Programming Language :: Python :: 2.6
  Classifier: Programming Language :: Python :: 2.7
  Classifier: Topic :: Internet :: WWW/HTTP
  Classifier: Environment :: Console


pkgId: 09da7e2d24a4fda93ef269d962a165ef130487bc768eae0f3dfb71c2eab8a561
name: python-airbyte
arch: src
version: 0.18.1
epoch: 0
release: 1
summary: PyAirbyte
url: https://pypi.org/project/airbyte/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-0.18.1-1.src.rpm
checksum_type: sha256
description:
  PyAirbyte brings the power of Airbyte to every Python developer. PyAirbyte provides a set of utilities to use Airbyte connectors in Python.

  [![PyPI version](https://badge.fury.io/py/airbyte.svg)](https://badge.fury.io/py/airbyte)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/airbyte)](https://pypi.org/project/airbyte/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/airbyte)](https://pypi.org/project/airbyte/)
  [![Star on GitHub](https://img.shields.io/github/stars/airbytehq/pyairbyte.svg?style=social&label=★%20on%20GitHub)](https://github.com/airbytehq/pyairbyte)



  Watch this [Getting Started Loom video](https://www.loom.com/share/3de81ca3ce914feca209bf83777efa3f?sid=8804e8d7-096c-4aaa-a8a4-9eb93a44e850) or run one of our Quickstart tutorials below to see how you can use PyAirbyte in your python code.

  * [Basic Demo](https://github.com/airbytehq/quickstarts/blob/main/pyairbyte_notebooks/PyAirbyte_Basic_Features_Demo.ipynb)
  * [CoinAPI](https://github.com/airbytehq/quickstarts/blob/main/pyairbyte_notebooks/PyAirbyte_CoinAPI_Demo.ipynb)
  * [GA4](https://github.com/airbytehq/quickstarts/blob/main/pyairbyte_notebooks/PyAirbyte_GA4_Demo.ipynb)
  * [Shopify](https://github.com/airbytehq/quickstarts/blob/main/pyairbyte_notebooks/PyAirbyte_Shopify_Demo.ipynb)
  * [GitHub](https://github.com/airbytehq/quickstarts/blob/main/pyairbyte_notebooks/PyAirbyte_Github_Incremental_Demo.ipynb)
  * [Postgres (cache)](https://github.com/airbytehq/quickstarts/blob/main/pyairbyte_notebooks/PyAirbyte_Postgres_Custom_Cache_Demo.ipynb)



  To learn how you can contribute to PyAirbyte, please see our [PyAirbyte Contributors Guide](./docs/CONTRIBUTING.md).



  **1. Does PyAirbyte replace Airbyte?**
  No. PyAirbyte is a Python library that allows you to use Airbyte connectors in Python, but it does not have orchestration
  or scheduling capabilities, nor does is provide logging, alerting, or other features for managing pipelines in
  production. Airbyte is a full-fledged data integration platform that provides connectors, orchestration, and scheduling capabilities.

  **2. What is the PyAirbyte cache? Is it a destination?**
  Yes and no. You can think of it as a built-in destination implementation, but we avoid the word "destination" in our docs to prevent confusion with our certified destinations list [here](https://docs.airbyte.com/integrations/destinations/).

  **3. Does PyAirbyte work with data orchestration frameworks like Airflow, Dagster, and Snowpark,**
  Yes, it should. Please give it a try and report any problems you see. Also, drop us a note if works for you!

  **4. Can I use PyAirbyte to develop or test when developing Airbyte sources?**
  Yes, you can. PyAirbyte makes it easy to test connectors in Python, and you can use it to develop new local connectors
  as well as existing already-published ones.

  **5. Can I develop traditional ETL pipelines with PyAirbyte?**
  Yes. Just pick the cache type matching the destination - like SnowflakeCache for landing data in Snowflake.

  **6. Can PyAirbyte import a connector from a local directory that has python project files, or does it have to be pip install**
  Yes, PyAirbyte can use any local install that has a CLI - and will automatically find connectors by name if they are on PATH.



  For a version history and list of all changes, please see our [GitHub Releases](https://github.com/airbytehq/PyAirbyte/releases) page.


pkgId: bb580d07d2074154a019c19369477cbb28fe58fbd5a07cde1a44a8669692c795
name: python-airbyte-api
arch: src
version: 0.52.1
epoch: 0
release: 1
summary: Python Client SDK for Airbyte API
url: https://github.com/airbytehq/airbyte-api-python-sdk.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-api-0.52.1-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
          <img src="https://user-images.githubusercontent.com/68016351/222853569-b35cc448-6481-4cf2-a237-bd5da47e94fd.png" width="500">
     <p>Programatically control Airbyte Cloud through an API.</p>
     <a href="https://reference.airbyte.com/reference/start"><img src="https://img.shields.io/static/v1?label=Docs&message=API Ref&color=000000&style=for-the-badge" /></a>
     <a href="https://github.com/airbytehq/airbyte-api-python-sdk/actions"><img src="https://img.shields.io/github/actions/workflow/status/airbytehq/airbyte-api-python-sdk/speakeasy_sdk_generation.yml?style=for-the-badge" /></a>
    <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge" /></a>
    <a href="https://github.com/airbytehq/airbyte-api-python-sdk/releases"><img src="https://img.shields.io/github/v/release/airbytehq/airbyte-api-python-sdk?sort=semver&style=for-the-badge" /></a>
  </div>



  Developers will need to create an API Key within your [Developer Portal](https://portal.airbyte.com/) to make API requests. You can use your existing Airbyte account to log in to the Developer Portal. Once you are in the Developer Portal, use the API Keys tab to create or remove API Keys. You can see a [walkthrough demo here](https://www.loom.com/share/7997a7c67cd642cc8d1c72ef0dfcc4bc)🎦

  The Developer Portal UI can also be used to help build your integration by showing information about network requests in the Requests tab. API usage information is also available to you in the Usage tab.

  <!-- Start Summary [summary] -->


  airbyte-api: Programatically control Airbyte Cloud, OSS & Enterprise.
  <!-- End Summary [summary] -->

  <!-- Start Table of Contents [toc] -->


  * [SDK Installation](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/#sdk-installation)
  * [SDK Example Usage](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/#sdk-example-usage)
  * [Available Resources and Operations](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/#available-resources-and-operations)
  * [Error Handling](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/#error-handling)
  * [Server Selection](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/#server-selection)
  * [Custom HTTP Client](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/#custom-http-client)
  * [Authentication](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/#authentication)
  <!-- End Table of Contents [toc] -->

  <!-- Start SDK Installation [installation] -->


  The SDK can be installed using the *pip* package manager, with dependencies and metadata stored in the `setup.py` file.

  ```bash
  pip install airbyte-api
  ```
  <!-- End SDK Installation [installation] -->

  <!-- Start SDK Example Usage [usage] -->




  ```python
  import airbyte_api
  from airbyte_api import models

  s = airbyte_api.AirbyteAPI(
      security=models.Security(
          basic_auth=models.SchemeBasicAuth(
              password="",
              username="",
          ),
      ),
  )


  res = s.connections.create_connection(request=models.ConnectionCreateRequest(
      destination_id='e478de0d-a3a0-475c-b019-25f7dd29e281',
      source_id='95e66a59-8045-4307-9678-63bc3c9b8c93',
      name='Postgres-to-Bigquery',
      namespace_format='${SOURCE_NAMESPACE}',
  ))

  if res.connection_response is not None:
      
      pass

  ```
  <!-- End SDK Example Usage [usage] -->

  <!-- Start Available Resources and Operations [operations] -->


  <details open>
  <summary>Available methods</summary>




  * [create_connection](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/connections/README.md#create_connection) - Create a connection
  * [delete_connection](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/connections/README.md#delete_connection) - Delete a Connection
  * [get_connection](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/connections/README.md#get_connection) - Get Connection details
  * [list_connections](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/connections/README.md#list_connections) - List connections
  * [patch_connection](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/connections/README.md#patch_connection) - Update Connection details



  * [create_destination](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/destinations/README.md#create_destination) - Create a destination
  * [delete_destination](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/destinations/README.md#delete_destination) - Delete a Destination
  * [get_destination](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/destinations/README.md#get_destination) - Get Destination details
  * [list_destinations](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/destinations/README.md#list_destinations) - List destinations
  * [patch_destination](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/destinations/README.md#patch_destination) - Update a Destination
  * [put_destination](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/destinations/README.md#put_destination) - Update a Destination and fully overwrite it



  * [get_health_check](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/health/README.md#get_health_check) - Health Check



  * [cancel_job](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/jobs/README.md#cancel_job) - Cancel a running Job
  * [create_job](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/jobs/README.md#create_job) - Trigger a sync or reset job of a connection
  * [get_job](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/jobs/README.md#get_job) - Get Job status and details
  * [list_jobs](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/jobs/README.md#list_jobs) - List Jobs by sync type



  * [list_organizations_for_user](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/organizations/README.md#list_organizations_for_user) - List all organizations for a user



  * [create_permission](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/permissions/README.md#create_permission) - Create a permission
  * [delete_permission](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/permissions/README.md#delete_permission) - Delete a Permission
  * [get_permission](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/permissions/README.md#get_permission) - Get Permission details
  * [list_permissions](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/permissions/README.md#list_permissions) - List Permissions by user id
  * [update_permission](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/permissions/README.md#update_permission) - Update a permission



  * [create_source](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/sources/README.md#create_source) - Create a source
  * [delete_source](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/sources/README.md#delete_source) - Delete a Source
  * [get_source](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/sources/README.md#get_source) - Get Source details
  * [initiate_o_auth](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/sources/README.md#initiate_o_auth) - Initiate OAuth for a source
  * [list_sources](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/sources/README.md#list_sources) - List sources
  * [patch_source](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/sources/README.md#patch_source) - Update a Source
  * [put_source](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/sources/README.md#put_source) - Update a Source and fully overwrite it



  * [get_stream_properties](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/streams/README.md#get_stream_properties) - Get stream properties



  * [list_users_within_an_organization](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/users/README.md#list_users_within_an_organization) - List all users within an organization



  * [create_or_update_workspace_o_auth_credentials](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/workspaces/README.md#create_or_update_workspace_o_auth_credentials) - Create OAuth override credentials for a workspace and source type.
  * [create_workspace](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/workspaces/README.md#create_workspace) - Create a workspace
  * [delete_workspace](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/workspaces/README.md#delete_workspace) - Delete a Workspace
  * [get_workspace](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/workspaces/README.md#get_workspace) - Get Workspace details
  * [list_workspaces](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/workspaces/README.md#list_workspaces) - List workspaces
  * [update_workspace](https://github.com/airbytehq/airbyte-api-python-sdk/blob/master/docs/sdks/workspaces/README.md#update_workspace) - Update a workspace

  </details>
  <!-- End Available Resources and Operations [operations] -->







  <!-- Start Error Handling [errors] -->


  Handling errors in this SDK should largely match your expectations.  All operations return a response object or raise an error.  If Error objects are specified in your OpenAPI Spec, the SDK will raise the appropriate Error type.

  | Error Object    | Status Code     | Content Type    |
  | --------------- | --------------- | --------------- |
  | errors.SDKError | 4xx-5xx         | */*             |



  ```python
  import airbyte_api
  from airbyte_api import errors, models

  s = airbyte_api.AirbyteAPI(
      security=models.Security(
          basic_auth=models.SchemeBasicAuth(
              password="",
              username="",
          ),
      ),
  )

  res = None
  try:
      res = s.connections.create_connection(request=models.ConnectionCreateRequest(
      destination_id='e478de0d-a3a0-475c-b019-25f7dd29e281',
      source_id='95e66a59-8045-4307-9678-63bc3c9b8c93',
      name='Postgres-to-Bigquery',
      namespace_format='${SOURCE_NAMESPACE}',
  ))

  except errors.SDKError as e:
      
      raise(e)

  if res.connection_response is not None:
      
      pass

  ```
  <!-- End Error Handling [errors] -->



  <!-- Start Server Selection [server] -->




  You can override the default server globally by passing a server index to the `server_idx: int` optional parameter when initializing the SDK client instance. The selected server will then be used as the default on the operations that use it. This table lists the indexes associated with the available servers:

  | # | Server | Variables |
  | - | ------ | --------- |
  | 0 | `https://api.airbyte.com/v1` | None |



  ```python
  import airbyte_api
  from airbyte_api import models

  s = airbyte_api.AirbyteAPI(
      server_idx=0,
      security=models.Security(
          basic_auth=models.SchemeBasicAuth(
              password="",
              username="",
          ),
      ),
  )


  res = s.connections.create_connection(request=models.ConnectionCreateRequest(
      destination_id='e478de0d-a3a0-475c-b019-25f7dd29e281',
      source_id='95e66a59-8045-4307-9678-63bc3c9b8c93',
      name='Postgres-to-Bigquery',
      namespace_format='${SOURCE_NAMESPACE}',
  ))

  if res.connection_response is not None:
      
      pass

  ```




  The default server can also be overridden globally by passing a URL to the `server_url: str` optional parameter when initializing the SDK client instance. For example:
  ```python
  import airbyte_api
  from airbyte_api import models

  s = airbyte_api.AirbyteAPI(
      server_url="https://api.airbyte.com/v1",
      security=models.Security(
          basic_auth=models.SchemeBasicAuth(
              password="",
              username="",
          ),
      ),
  )


  res = s.connections.create_connection(request=models.ConnectionCreateRequest(
      destination_id='e478de0d-a3a0-475c-b019-25f7dd29e281',
      source_id='95e66a59-8045-4307-9678-63bc3c9b8c93',
      name='Postgres-to-Bigquery',
      namespace_format='${SOURCE_NAMESPACE}',
  ))

  if res.connection_response is not None:
      
      pass

  ```
  <!-- End Server Selection [server] -->



  <!-- Start Custom HTTP Client [http-client] -->


  The Python SDK makes API calls using the [requests](https://pypi.org/project/requests/) HTTP library.  In order to provide a convenient way to configure timeouts, cookies, proxies, custom headers, and other low-level configuration, you can initialize the SDK client with a custom `requests.Session` object.

  For example, you could specify a header for every request that this sdk makes as follows:
  ```python
  import airbyte_api
  import requests

  http_client = requests.Session()
  http_client.headers.update({'x-custom-header': 'someValue'})
  s = airbyte_api.AirbyteAPI(client=http_client)
  ```
  <!-- End Custom HTTP Client [http-client] -->



  <!-- Start Authentication [security] -->




  This SDK supports the following security schemes globally:

  | Name                 | Type                 | Scheme               |
  | -------------------- | -------------------- | -------------------- |
  | `basic_auth`         | http                 | HTTP Basic           |
  | `bearer_auth`        | http                 | HTTP Bearer          |
  | `client_credentials` | oauth2               | OAuth2 token         |

  You can set the security parameters through the `security` optional parameter when initializing the SDK client instance. The selected scheme will be used by default to authenticate with the API for all operations that support it. For example:
  ```python
  import airbyte_api
  from airbyte_api import models

  s = airbyte_api.AirbyteAPI(
      security=models.Security(
          basic_auth=models.SchemeBasicAuth(
              password="",
              username="",
          ),
      ),
  )


  res = s.connections.create_connection(request=models.ConnectionCreateRequest(
      destination_id='e478de0d-a3a0-475c-b019-25f7dd29e281',
      source_id='95e66a59-8045-4307-9678-63bc3c9b8c93',
      name='Postgres-to-Bigquery',
      namespace_format='${SOURCE_NAMESPACE}',
  ))

  if res.connection_response is not None:
      
      pass

  ```
  <!-- End Authentication [security] -->

  <!-- Placeholder for Future Speakeasy SDK Sections -->





  This SDK is in beta, and there may be breaking changes between versions without a major version update. Therefore, we recommend pinning usage
  to a specific package version. This way, you can install the same version each time without breaking changes unless you are intentionally
  looking for the latest version.



  While we value open-source contributions to this SDK, this library is generated programmatically.
  Feel free to open a PR or a Github issue as a proof of concept and we'll do our best to include it in a future release !


pkgId: 8a0dff93ce9cd4d7012b0fb4c3c7e1947202cb7d0f237cc8213d3b65aa6386b6
name: python-airbyte-cdk
arch: src
version: 5.13.0
epoch: 0
release: 1
summary: A framework for writing Airbyte Connectors.
url: https://github.com/airbytehq/airbyte
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-cdk-5.13.0-1.src.rpm
checksum_type: sha256
description:
  Airbyte Python CDK is a framework for building Airbyte API Source Connectors. It provides a set of
  classes and helpers that make it easy to build a connector against an HTTP API (REST, GraphQL, etc),
  or a generic Python source connector.



  If you're looking to build a connector, we highly recommend that you
  [start with the Connector Builder](https://docs.airbyte.com/connector-development/connector-builder-ui/overview).
  It should be enough for 90% connectors out there. For more flexible and complex connectors, use the
  [low-code CDK and `SourceDeclarativeManifest`](https://docs.airbyte.com/connector-development/config-based/low-code-cdk-overview).

  If that doesn't work, then consider building on top of the
  [lower-level Python CDK itself](https://docs.airbyte.com/connector-development/cdk-python/).



  To get started on a Python CDK based connector or a low-code connector, you can generate a connector
  project from a template:

  ```bash

  cd airbyte-integrations/connector-templates/generator
  ./generate.sh
  ```



  **HTTP Connectors**:

  - [Stripe](https://github.com/airbytehq/airbyte/blob/master/airbyte-integrations/connectors/source-stripe/)
  - [Salesforce](https://github.com/airbytehq/airbyte/blob/master/airbyte-integrations/connectors/source-salesforce/)

  **Python connectors using the bare-bones `Source` abstraction**:

  - [Google Sheets](https://github.com/airbytehq/airbyte/blob/master/airbyte-integrations/connectors/source-google-sheets/google_sheets_source/google_sheets_source.py)

  This will generate a project with a type and a name of your choice and put it in
  `airbyte-integrations/connectors`. Open the directory with your connector in an editor and follow
  the `TODO` items.



  Airbyte CDK code is within `airbyte_cdk` directory. Here's a high level overview of what's inside:

  - `connector_builder`. Internal wrapper that helps the Connector Builder platform run a declarative
    manifest (low-code connector). You should not use this code directly. If you need to run a
    `SourceDeclarativeManifest`, take a look at
    [`source-declarative-manifest`](https://github.com/airbytehq/airbyte/tree/master/airbyte-integrations/connectors/source-declarative-manifest)
    connector implementation instead.
  - `destinations`. Basic Destination connector support! If you're building a Destination connector in
    Python, try that. Some of our vector DB destinations like `destination-pinecone` are using that
    code.
  - `models` expose `airbyte_protocol.models` as a part of `airbyte_cdk` package.
  - `sources/concurrent_source` is the Concurrent CDK implementation. It supports reading data from
    streams concurrently per slice / partition, useful for connectors with high throughput and high
    number of records.
  - `sources/declarative` is the low-code CDK. It works on top of Airbyte Python CDK, but provides a
    declarative manifest language to define streams, operations, etc. This makes it easier to build
    connectors without writing Python code.
  - `sources/file_based` is the CDK for file-based sources. Examples include S3, Azure, GCS, etc.



  Thank you for being interested in contributing to Airbyte Python CDK! Here are some guidelines to
  get you started:

  - We adhere to the [code of conduct](/CODE_OF_CONDUCT.md).
  - You can contribute by reporting bugs, posting github discussions, opening issues, improving
    [documentation](/docs/), and submitting pull requests with bugfixes and new features alike.
  - If you're changing the code, please add unit tests for your change.
  - When submitting issues or PRs, please add a small reproduction project. Using the changes in your
    connector and providing that connector code as an example (or a satellite PR) helps!



  Install the project dependencies and development tools:

  ```bash
  poetry install --all-extras
  ```

  Installing all extras is required to run the full suite of unit tests.



  - Iterate on the CDK code locally
  - Run tests via `poetry run poe unit-test-with-cov`, or `python -m pytest -s unit_tests` if you want
    to pass pytest options.
  - Run `poetry run poe check-local` to lint all code, type-check modified code, and run unit tests
    with coverage in one command.

  To see all available scripts, run `poetry run poe`.



  Low-code CDK models are generated from `sources/declarative/declarative_component_schema.yaml`. If
  the iteration you are working on includes changes to the models or the connector generator, you
  might want to regenerate them. In order to do that, you can run:

  ```bash
  poetry run poe build
  ```

  This will generate the code generator docker image and the component manifest files based on the
  schemas and templates.



  All tests are located in the `unit_tests` directory. Run `poetry run poe unit-test-with-cov` to run
  them. This also presents a test coverage report. For faster iteration with no coverage report and
  more options, `python -m pytest -s unit_tests` is a good place to start.



  When developing a new feature in the CDK, you may find it helpful to run a connector that uses that
  new feature. You can test this in one of two ways:

  - Running a connector locally
  - Building and running a source via Docker



  Open the connector's `pyproject.toml` file and replace the line with `airbyte_cdk` with the
  following:

  ```toml
  airbyte_cdk = { path = "../../../airbyte-cdk/python/airbyte_cdk", develop = true }
  ```

  Then, running `poetry update` should reinstall `airbyte_cdk` from your local working directory.



  _Pre-requisite: Install the
  [`airbyte-ci` CLI](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)_

  You can build your connector image with the local CDK using

  ```bash

  airbyte-ci connectors --use-local-cdk --name=<CONNECTOR> build
  ```

  Note that the local CDK is injected at build time, so if you make changes, you will have to run the
  build command again to see them reflected.



  _Pre-requisite: Install the
  [`airbyte-ci` CLI](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)_

  To run acceptance tests for a single connectors using the local CDK, from the connector directory,
  run

  ```bash
  airbyte-ci connectors --use-local-cdk --name=<CONNECTOR> test
  ```



  There may be a time when you do not have access to the API (either because you don't have the
  credentials, network access, etc...) You will probably still want to do end-to-end testing at least
  once. In order to do so, you can emulate the server you would be reaching using a server stubbing
  tool.

  For example, using [mockserver](https://www.mock-server.com/), you can set up an expectation file
  like this:

  ```json
  {
    "httpRequest": {
      "method": "GET",
      "path": "/data"
    },
    "httpResponse": {
      "body": "{\"data\": [{\"record_key\": 1}, {\"record_key\": 2}]}"
    }
  }
  ```

  Assuming this file has been created at `secrets/mock_server_config/expectations.json`, running the
  following command will allow to match any requests on path `/data` to return the response defined in
  the expectation file:

  ```bash
  docker run -d --rm -v $(pwd)/secrets/mock_server_config:/config -p 8113:8113 --env MOCKSERVER_LOG_LEVEL=TRACE --env MOCKSERVER_SERVER_PORT=8113 --env MOCKSERVER_WATCH_INITIALIZATION_JSON=true --env MOCKSERVER_PERSISTED_EXPECTATIONS_PATH=/config/expectations.json --env MOCKSERVER_INITIALIZATION_JSON_PATH=/config/expectations.json mockserver/mockserver:5.15.0
  ```

  HTTP requests to `localhost:8113/data` should now return the body defined in the expectations file.
  To test this, the implementer either has to change the code which defines the base URL for Python
  source or update the `url_base` from low-code. With the Connector Builder running in docker, you
  will have to use domain `host.docker.internal` instead of `localhost` as the requests are executed
  within docker.



  Python CDK has a
  [GitHub workflow](https://github.com/airbytehq/airbyte/actions/workflows/publish-cdk-command-manually.yml)
  that manages the CDK changelog, making a new release for `airbyte_cdk`, publishing it to PyPI, and
  then making a commit to update (and subsequently auto-release)
  [`source-declarative-m
  anifest`](https://github.com/airbytehq/airbyte/tree/master/airbyte-integrations/connectors/source-declarative-manifest)
  and Connector Builder (in the platform repository).

  > [!Note]: The workflow will handle the `CHANGELOG.md` entry for you. You should not add changelog
  > lines in your PRs to the CDK itself.

  > [!Warning]: The workflow bumps version on it's own, please don't change the CDK version in
  > `pyproject.toml` manually.

  1. You only trigger the release workflow once all the PRs that you want to be included are already
     merged into the `master` branch.
  2. The
     [`Publish CDK Manually`](https://github.com/airbytehq/airbyte/actions/workflows/publish-cdk-command-manually.yml)
     workflow from master using `release-type=major|manor|patch` and setting the changelog message.
  3. When the workflow runs, it will commit a new version directly to master branch.
  4. The workflow will bump the version of `source-declarative-manifest` according to the
     `release-type` of the CDK, then commit these changes back to master. The commit to master will
     kick off a publish of the new version of `source-declarative-manifest`.
  5. The workflow will also add a pull request to `airbyte-platform-internal` repo to bump the
     dependency in Connector Builder.


pkgId: 986a34ec634e05d8f7d2611bc44c9a533dbd86151624a81c57ca5cc5d511774e
name: python-airbyte-cdk
arch: src
version: 6.7.1
epoch: 0
release: 1
summary: A framework for writing Airbyte Connectors.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-cdk-6.7.1-1.src.rpm
checksum_type: sha256
description:
  Airbyte Python CDK is a framework for building Airbyte API Source Connectors. It provides a set of
  classes and helpers that make it easy to build a connector against an HTTP API (REST, GraphQL, etc),
  or a generic Python source connector.



  If you're looking to build a connector, we highly recommend that you
  [start with the Connector Builder](https://docs.airbyte.com/connector-development/connector-builder-ui/overview).
  It should be enough for 90% connectors out there. For more flexible and complex connectors, use the
  [low-code CDK and `SourceDeclarativeManifest`](https://docs.airbyte.com/connector-development/config-based/low-code-cdk-overview).

  If that doesn't work, then consider building on top of the
  [lower-level Python CDK itself](https://docs.airbyte.com/connector-development/cdk-python/).



  To get started on a Python CDK based connector or a low-code connector, you can generate a connector
  project from a template:

  ```bash

  cd airbyte-integrations/connector-templates/generator
  ./generate.sh
  ```



  **HTTP Connectors**:

  - [Stripe](https://github.com/airbytehq/airbyte/blob/master/airbyte-integrations/connectors/source-stripe/)
  - [Salesforce](https://github.com/airbytehq/airbyte/blob/master/airbyte-integrations/connectors/source-salesforce/)

  **Python connectors using the bare-bones `Source` abstraction**:

  - [Google Sheets](https://github.com/airbytehq/airbyte/blob/master/airbyte-integrations/connectors/source-google-sheets/google_sheets_source/google_sheets_source.py)

  This will generate a project with a type and a name of your choice and put it in
  `airbyte-integrations/connectors`. Open the directory with your connector in an editor and follow
  the `TODO` items.



  Airbyte CDK code is within `airbyte_cdk` directory. Here's a high level overview of what's inside:

  - `connector_builder`. Internal wrapper that helps the Connector Builder platform run a declarative
    manifest (low-code connector). You should not use this code directly. If you need to run a
    `SourceDeclarativeManifest`, take a look at
    [`source-declarative-manifest`](https://github.com/airbytehq/airbyte/tree/master/airbyte-integrations/connectors/source-declarative-manifest)
    connector implementation instead.
  - `destinations`. Basic Destination connector support! If you're building a Destination connector in
    Python, try that. Some of our vector DB destinations like `destination-pinecone` are using that
    code.
  - `models` expose `airbyte_protocol.models` as a part of `airbyte_cdk` package.
  - `sources/concurrent_source` is the Concurrent CDK implementation. It supports reading data from
    streams concurrently per slice / partition, useful for connectors with high throughput and high
    number of records.
  - `sources/declarative` is the low-code CDK. It works on top of Airbyte Python CDK, but provides a
    declarative manifest language to define streams, operations, etc. This makes it easier to build
    connectors without writing Python code.
  - `sources/file_based` is the CDK for file-based sources. Examples include S3, Azure, GCS, etc.



  Thank you for being interested in contributing to Airbyte Python CDK! Here are some guidelines to
  get you started:

  - We adhere to the [code of conduct](/CODE_OF_CONDUCT.md).
  - You can contribute by reporting bugs, posting github discussions, opening issues, improving
    [documentation](/docs/), and submitting pull requests with bugfixes and new features alike.
  - If you're changing the code, please add unit tests for your change.
  - When submitting issues or PRs, please add a small reproduction project. Using the changes in your
    connector and providing that connector code as an example (or a satellite PR) helps!



  Install the project dependencies and development tools:

  ```bash
  poetry install --all-extras
  ```

  Installing all extras is required to run the full suite of unit tests.



  - Iterate on the CDK code locally
  - Run tests via `poetry run poe unit-test-with-cov`, or `python -m pytest -s unit_tests` if you want
    to pass pytest options.
  - Run `poetry run poe check-local` to lint all code, type-check modified code, and run unit tests
    with coverage in one command.

  To see all available scripts, run `poetry run poe`.



  - Iterate on the CDK code locally
  - Run `poetry run ruff format` to format your changes.

  To see all available `ruff` options, run `poetry run ruff`.



  Low-code CDK models are generated from `sources/declarative/declarative_component_schema.yaml`. If
  the iteration you are working on includes changes to the models or the connector generator, you
  might want to regenerate them. In order to do that, you can run:

  ```bash
  poetry run poe build
  ```

  This will generate the code generator docker image and the component manifest files based on the
  schemas and templates.



  All tests are located in the `unit_tests` directory. Run `poetry run poe unit-test-with-cov` to run
  them. This also presents a test coverage report. For faster iteration with no coverage report and
  more options, `python -m pytest -s unit_tests` is a good place to start.



  When developing a new feature in the CDK, you may find it helpful to run a connector that uses that
  new feature. You can test this in one of two ways:

  - Running a connector locally
  - Building and running a source via Docker



  Open the connector's `pyproject.toml` file and replace the line with `airbyte_cdk` with the
  following:

  ```toml
  airbyte_cdk = { path = "../../../airbyte-cdk/python/airbyte_cdk", develop = true }
  ```

  Then, running `poetry update` should reinstall `airbyte_cdk` from your local working directory.



  _Pre-requisite: Install the
  [`airbyte-ci` CLI](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)_

  You can build your connector image with the local CDK using

  ```bash

  airbyte-ci connectors --use-local-cdk --name=<CONNECTOR> build
  ```

  Note that the local CDK is injected at build time, so if you make changes, you will have to run the
  build command again to see them reflected.



  _Pre-requisite: Install the
  [`airbyte-ci` CLI](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)_

  To run acceptance tests for a single connectors using the local CDK, from the connector directory,
  run

  ```bash
  airbyte-ci connectors --use-local-cdk --name=<CONNECTOR> test
  ```



  There may be a time when you do not have access to the API (either because you don't have the
  credentials, network access, etc...) You will probably still want to do end-to-end testing at least
  once. In order to do so, you can emulate the server you would be reaching using a server stubbing
  tool.

  For example, using [mockserver](https://www.mock-server.com/), you can set up an expectation file
  like this:

  ```json
  {
    "httpRequest": {
      "method": "GET",
      "path": "/data"
    },
    "httpResponse": {
      "body": "{\"data\": [{\"record_key\": 1}, {\"record_key\": 2}]}"
    }
  }
  ```

  Assuming this file has been created at `secrets/mock_server_config/expectations.json`, running the
  following command will allow to match any requests on path `/data` to return the response defined in
  the expectation file:

  ```bash
  docker run -d --rm -v $(pwd)/secrets/mock_server_config:/config -p 8113:8113 --env MOCKSERVER_LOG_LEVEL=TRACE --env MOCKSERVER_SERVER_PORT=8113 --env MOCKSERVER_WATCH_INITIALIZATION_JSON=true --env MOCKSERVER_PERSISTED_EXPECTATIONS_PATH=/config/expectations.json --env MOCKSERVER_INITIALIZATION_JSON_PATH=/config/expectations.json mockserver/mockserver:5.15.0
  ```

  HTTP requests to `localhost:8113/data` should now return the body defined in the expectations file.
  To test this, the implementer either has to change the code which defines the base URL for Python
  source or update the `url_base` from low-code. With the Connector Builder running in docker, you
  will have to use domain `host.docker.internal` instead of `localhost` as the requests are executed
  within docker.



  Python CDK has a
  [GitHub workflow](https://github.com/airbytehq/airbyte/actions/workflows/publish-cdk-command-manually.yml)
  that manages the CDK changelog, making a new release for `airbyte_cdk`, publishing it to PyPI, and
  then making a commit to update (and subsequently auto-release)
  [`source-declarative-m
  anifest`](https://github.com/airbytehq/airbyte/tree/master/airbyte-integrations/connectors/source-declarative-manifest)
  and Connector Builder (in the platform repository).

  > [!Note]: The workflow will handle the `CHANGELOG.md` entry for you. You should not add changelog
  > lines in your PRs to the CDK itself.

  > [!Warning]: The workflow bumps version on it's own, please don't change the CDK version in
  > `pyproject.toml` manually.

  1. You only trigger the release workflow once all the PRs that you want to be included are already
     merged into the `master` branch.
  2. The
     [`Publish CDK Manually`](https://github.com/airbytehq/airbyte/actions/workflows/publish-cdk-command-manually.yml)
     workflow from master using `release-type=major|manor|patch` and setting the changelog message.
  3. When the workflow runs, it will commit a new version directly to master branch.
  4. The workflow will bump the version of `source-declarative-manifest` according to the
     `release-type` of the CDK, then commit these changes back to master. The commit to master will
     kick off a publish of the new version of `source-declarative-manifest`.
  5. The workflow will also add a pull request to `airbyte-platform-internal` repo to bump the
     dependency in Connector Builder.


pkgId: 49cae1575064cdffbf0c5869d093580078c125e2b7516cd827ba8f7569cedf71
name: python-airbyte-cdk
arch: src
version: 6.9.0
epoch: 0
release: 1
summary: A framework for writing Airbyte Connectors.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-cdk-6.9.0-1.src.rpm
checksum_type: sha256
description:
  Airbyte Python CDK is a framework for building Airbyte API Source Connectors. It provides a set of
  classes and helpers that make it easy to build a connector against an HTTP API (REST, GraphQL, etc),
  or a generic Python source connector.



  If you're looking to build a connector, we highly recommend that you first
  [start with the Connector Builder](https://docs.airbyte.com/connector-development/connector-builder-ui/overview).
  It should be enough for 90% connectors out there. For more flexible and complex connectors, use the
  [low-code CDK and `SourceDeclarativeManifest`](https://docs.airbyte.com/connector-development/config-based/low-code-cdk-overview).

  For more information on building connectors, please see the [Connector Development](https://docs.airbyte.com/connector-development/) guide on [docs.airbyte.com](https://docs.airbyte.com).



  Airbyte CDK code is within `airbyte_cdk` directory. Here's a high level overview of what's inside:

  - `airbyte_cdk/connector_builder`. Internal wrapper that helps the Connector Builder platform run a declarative manifest (low-code connector). You should not use this code directly. If you need to run a `SourceDeclarativeManifest`, take a look at [`source-declarative-manifest`](https://github.com/airbytehq/airbyte/tree/master/airbyte-integrations/connectors/source-declarative-manifest) connector implementation instead.
  - `airbyte_cdk/cli/source_declarative_manifest`. This module defines the `source-declarative-manifest` (aka "SDM") connector execution logic and associated CLI.
  - `airbyte_cdk/destinations`. Basic Destination connector support! If you're building a Destination connector in Python, try that. Some of our vector DB destinations like `destination-pinecone` are using that code.
  - `airbyte_cdk/models` expose `airbyte_protocol.models` as a part of `airbyte_cdk` package.
  - `airbyte_cdk/sources/concurrent_source` is the Concurrent CDK implementation. It supports reading data from streams concurrently per slice / partition, useful for connectors with high throughput and high number of records.
  - `airbyte_cdk/sources/declarative` is the low-code CDK. It works on top of Airbyte Python CDK, but provides a declarative manifest language to define streams, operations, etc. This makes it easier to build connectors without writing Python code.
  - `airbyte_cdk/sources/file_based` is the CDK for file-based sources. Examples include S3, Azure, GCS, etc.



  For instructions on how to contribute, please see our [Contributing Guide](docs/CONTRIBUTING.md).



  Please see the [Release Management](docs/RELEASES.md) guide for information on how to perform releases and pre-releases.


pkgId: c52af5c91e2c184b4ad8b55aaafba7d4619c37feb9c42c18548c9fe7562de796
name: python-airbyte-serverless
arch: src
version: 0.30
epoch: 0
release: 1
summary: Airbyte made easy (no UI, no database, no cluster)
url: https://pypi.org/project/airbyte-serverless/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-serverless-0.30-1.src.rpm
checksum_type: sha256
description:
  <br>

  AirbyteServerless is a simple tool to **manage Airbyte connectors**, run them **locally** or deploy them in **serverless** mode.
  ![logo](https://raw.githubusercontent.com/unytics/airbyte_serverless/main/airbyte_serverless.gif)
  <br>

  [Airbyte](https://airbyte.com/) is a must-have in your data-stack with its **catalog of open-source connectors to move your data from any source to your data-warehouse**.
  To manage these connectors, Airbyte offers **Airbyte-Open-Source-Platform** which includes a server, workers, database, UI, orchestrator, connectors, secret manager, logs manager, etc.
  AirbyteServerless aims at offering **a lightweight alternative** to Airbyte-Open-Source-Platform to simplify connectors management.
  <br>

  | Airbyte-Open-Source-Platform    | AirbyteServerless |
  | -------- | ------- |
  | **Has a UI** | **Has NO UI**<br>Connections configurations are managed by documented yaml files |
  | **Has a database**  | **Has NO database**<br>- Configurations files are versioned in git<br>- The destination stores the `state` (the [checkpoint](https://airbyte.com/blog/checkpointing) of where sync stops) and `logs` which can then be visualized with your preferred BI tool |
  | **Has a transform layer**<br>Airbyte loads your data in a raw format but then enables you to perform basic transform such as replace, upsert, [schema normalization](https://docs.airbyte.com/understanding-airbyte/basic-normalization/)   | **Has NO transform layer**<br>- Data is appended in your destination in raw format.<br>- `airbyte_serverless` is dedicated to do one thing and do it well: `Extract-Load`. |
  | **NOT Serverless**<br>- Can be deployed on a VM or Kubernetes Cluster.<br>- The platform is made of tens of dependent containers that you CANNOT deploy with serverless  | **Serverless**<br>- An Airbyte source docker image is upgraded with a destination connector<br>- The upgraded docker image can then be deployed as an isolated `Cloud Run Job` (or `Cloud Run Service`)<br>- Cloud Run is natively monitored with metrics, dashboards, logs, error reporting, alerting, etc<br>- It can be scheduled or triggered by events  |
  | **Is scalable with conditions**<br>Scalable if deployed on autoscaled Kubernetes Cluster and if you are skilled enough.<br>👉 **Check that you are skilled enough with Kubernetes by watching [this video](https://www.youtube.com/watch?v=9wvEwPLcLcA)** 😁. | **Is scalable**<br>Each connector is deployed independently of each other. You can have as many as you want. |
  <br>

  `abs` is the CLI (command-line-interface) of AirbyteServerless which facilitates connectors management.

  ``` sh
  pip install airbyte-serverless
  ```

  ``` sh
  abs create my_first_connection --source="airbyte/source-faker:0.1.4" --destination="bigquery" --remote-runner "cloud_run_job"
  ```
  > 1. Docker is required. Make sure you have it installed. (IF YOU DON'T HAVE DOCKER AND WANT TO RUN A PYTHON CONNECTOR, READ NEXT SECTION)
  > 2. `source` param can be any Public Docker Airbyte Source ([here](https://hub.docker.com/search?q=airbyte%2Fsource-) is the list). We recomend that you use faker source to get started.
  > 3. `destination` param must be one of the following:
  >     - `print` (default value if not set)
  >     - `bigquery`
  >     - *contributions are welcome to offer more destinations* 🤗
  > 4. `remote-runner` param must be `cloud_run_job`. More integrations will come in the future. This remote-runner is only used if you want to run the connection on a remote runner and schedule it.
  > 5. The command will create a configuration file `./connections/my_first_connection.yaml` with initialized configuration.
  > 6. Update this configuration file to suit your needs.

  Actually, `source` argument can be a docker image as above or any command.
  Below, we use `pipx` tool to run [`airbyte-source-faker` python package available on pypi](https://pypi.org/project/airbyte-source-faker/).
  ``` sh
  abs create my_first_connection --source="pipx run airbyte-source-faker==0.1.4"
  ```
  The value just after `pipx run` can be any Airbyte Python Source [available on pypi](https://pypi.org/search/?q=airbyte-source-). For security reasons, beware to check that the source you are going to install is really from Airbyte.
  The other arguments are the same as before.

  ``` sh
  abs run my_first_connection
  ```
  > 1. This will launch an Extract-Load Job from the source to the destination.
  > 2. The `run` commmand will only work if you have correctly edited `./connections/my_first_connection.yaml` configuration file.
  > 3. If you chose `bigquery` destination, you must:
  >    + have `gcloud` installed on your machine with default credentials initialized with the command `gcloud auth application-default login`.
  >    + have correctly edited the `destination` section of `./connections/my_first_connection.yaml` configuration file. You must have `dataEditor` permission on the chosen BigQuery dataset.
  > 4. Data is always appended at destination (not replaced nor upserted). It will be in raw format.
  > 5. If the connector supports incremental extract (extract only new or recently modified data) then this mode is chosen.

  You may not want to copy all the data that the source can get. To see all available `streams` run:
  ``` sh
  abs list-available-streams my_first_connection
  ```
  If you want to configure your connection with only some of these streams, run:
  ``` sh
  abs set-streams my_first_connection "stream1,stream2"
  ```
  Next `run` executions will extract selected streams only.

  For security reasons, you do NOT want to store secrets such as api tokens in your yaml files. Instead, add your secrets in Google Secret Manager by following [this documentation](https://cloud.google.com/secret-manager/docs/create-secret-quickstart). Then you can add the secret resource name in the yaml file such as below:
  ```yaml
  source:
    docker_image: "..."
    config:
      api_token: GCP_SECRET({SECRET_RESOURCE_NAME})
  ```
  Replace `{SECRET_RESOURCE_NAME}` by your secret resource name which must have the format: `projects/{PROJECT_ID}/secrets/{SECRET_ID}/versions/{SECRET_VERSION}`. To get this path:
  > 1. Go to the [Secret Manager page](https://console.cloud.google.com/security/secret-manager) in the Google Cloud console.
  > 2. Go to the Secret Manager page
  > 3. On the Secret Manager page, click on the Name of a secret.
  > 4. On the Secret details page, in the Versions table, locate a secret version to access.
  > 5. In the Actions column, click on the three dots.
  > 6. Click on 'Copy Resource Name' from the menu.

  WARNING: THIS ONLY WORKS FOR NOW WITH A DOCKER SOURCE in python language.
  ``` sh
  abs remote-run my_first_connection
  ```
  > 2. The `remote-run` commmand will only work if you have correctly edited `./connections/my_first_connection.yaml` configuration file including the `remote_runner` part.
  > 1. This command will launch an Extract-Load Job like the `abs run` command. The main difference is that the command will be run on a remote deployed container (we use Cloud Run Job as the only container runner for now).
  > 3. If you chose `bigquery` destination, the service account you put in `service_account` field of `remote_runner` section of the yaml must be `bigquery.dataEditor` on the target dataset and have permission to create some BigQuery jobs in the project.
  > 4. If your yaml config contains some Google Secrets, the service account you put in `service_account` field of `remote_runner` section of the yaml must have read access to the secrets.

  When you create a connection using `abs create my_connection --source "SOURCE"`, you can put any docker image you have access to as `SOURCE`. So `SOURCE` can be:
  - a public docker image from Docker Hub
  - a local docker image that you built
  - a docker image that you built and pushed on [Google Artifact Registry](https://cloud.google.com/artifact-registry/docs/docker).
  To run remotely on a cloud run job, the image must be available to Cloud Run (so cannot be local). It must be either public from Docker Hub or from Google Artifact Registry.

  ``` sh
  abs schedule-remote-run my_first_connection "0 * * * *"
  ```
  > ⚠️ THIS IS NOT IMPLEMENTED YET

  ``` sh
  $ abs --help
  Usage: abs [OPTIONS] COMMAND [ARGS]...
  Options:
    --help  Show this message and exit.
  Commands:
    create                  Create CONNECTION
    list                    List created connections
    list-available-streams  List available streams of CONNECTION
    remote-run              Run CONNECTION Extract-Load Job from remote runner
    run                     Run CONNECTION Extract-Load Job
    run-env-vars            Run Extract-Load Job configured by environment...
    set-streams             Set STREAMS to retrieve for CONNECTION (STREAMS...
  ```
  <br>

  <details>
    <summary><b>Is it easy to migrate from/to Airbyte?</b></summary>
    <br>
    1. AirbyteServerless uses Airbyte source connectors. Then, the same config is used. If it works on AirbyteServerless, it will work on Airbyte. The reverse may be sometimes a bit harder if for some sources you created credentials using oauth2 (with a pop-up window from the source opened by Airbyte UI). Indeed, Airbyte may not give you a way to read these created credentials.
    2. Airbyte jobs have two steps: extract-load of raw data and optional transform (transform can be replace, upsert, basic normalization). The extract-load of raw data is exactly the same but AirbyteServerless does not do transform. It only appends raw data at the destination. This is for purpose as AirbyteServerless was made to do only one thing and do it well and we believe it makes it resilient to schema changes. Then,
        - if you create your transforms from raw data on dbt, you will be able to migrate from AirbyteServerless to Airbyte and vice-versa and still use your transforms.
        - if you use Airbyte and rely on Airbyte transforms, you will need to re-create them in dbt if you switch to AirbyteServerless
    3. When migrating from/to Airbyte Cloud ↔ Airbyte OSS self-deployed ↔ AirbyteServerless, you won't be able to copy the state (which stores where incremental jobs stop). Then you will need to make a full refresh.
    <br>
  </details>
  <details>
    <summary><b>Why cannot we use usual Airbyte destination connectors?</b></summary>
    <br>
    Airbyte-Serverless destination connectors are indeed specific to AirbyteServerless and can NOT be the ones from Airbyte. This is because, in AirbyteServerless, destination connectors manage the states and logs while in Airbyte this is handled by the platform. Thanks to this, we don't need a database 🥳!
    This being said, AirbyteServerless destination connectors are very light. You'll find [here](https://github.com/unytics/airbyte_serverless/blob/main/airbyte_serverless/destinations.py#L105) that the BigQuery destination connector is only 50 lines of code.
    <br>
  </details>
  <br>

  [Join our Slack](https://join.slack.com/t/unytics/shared_invite/zt-1gbv491mu-cs03EJbQ1fsHdQMcFN7E1Q) for any question, to get help for getting started, to speak about a bug, to suggest improvements, or simply if you want to have a chat 🙂.
  <br>

  Any contribution is more than welcome 🤗!
  - Add a ⭐ on the repo to show your support
  - [Join our Slack](https://join.slack.com/t/unytics/shared_invite/zt-1gbv491mu-cs03EJbQ1fsHdQMcFN7E1Q) and talk with us
  - Raise an issue to raise a bug or suggest improvements
  - Open a PR! Below are some suggestions of work to be done:
    - implements a scheduler
    - create a very light python Airbyte source / add a tutorial to use it in abs
    - implement the `get_logs` method of `BigQueryDestination`
    - use the new BigQuery Storage Write API for bigquery destination
    - enable updating cloud run job instead of deleting/creating when it already exists
    - add a new destination connector (Cloud Storage?)
    - add more remote runners such compute instances.
    - implements vpc access
    - implement optional post-processing (replace, upsert data at destination instead of append?)
  <br>

  - Big kudos to Airbyte for all the hard work on connectors!
  - The generation of the sample connector configuration in yaml is heavily inspired from the code of `octavia` CLI developed by Airbyte.


pkgId: 3b9cc7ca8353c80607042d5aa1ec56f13c1c98b8386f7040eb0fbebf35f18eeb
name: python-airbyte-source-adjust
arch: src
version: 0.1.25
epoch: 0
release: 1
summary: Source implementation for Adjust.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-adjust-0.1.25-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Adjust configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/adjust).




  * Python (~=3.9)
  * Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/adjust)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_adjust/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



  ```
  poetry run source-adjust spec
  poetry run source-adjust check --config secrets/config.json
  poetry run source-adjust discover --config secrets/config.json
  poetry run source-adjust read --config secrets/config.json --catalog integration_tests/configured_catalog.json
  ```


  To run unit tests locally, from the connector directory run:
  ```
  poetry run pytest unit_tests
  ```


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-adjust build
  ```

  An image will be available on your host with the tag `airbyte/source-adjust:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-adjust:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-adjust:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-adjust:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-adjust:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```


  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-adjust test
  ```


  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.


  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.


  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-adjust test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/adjust.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


pkgId: b901ba6c36bb665086192613adf8a38bce38a6e70fb8160d4d4ba7eae0571159
name: python-airbyte-source-aha
arch: src
version: 0.3.14
epoch: 0
release: 1
summary: Source implementation for aha.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-aha-0.3.14-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Aha configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/aha).





  * Python (`^3.9`)
  * Poetry (`^1.7`) - installation instructions [here](https://python-poetry.org/docs/#installation)





  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```




  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/aha)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `src/source_aha/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.




  ```
  poetry run source-aha spec
  poetry run source-aha check --config secrets/config.json
  poetry run source-aha discover --config secrets/config.json
  poetry run source-aha read --config secrets/config.json --catalog integration_tests/configured_catalog.json
  ```



  To run tests locally, from the connector directory run:

  ```
  poetry run pytest tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-aha build
  ```

  An image will be available on your host with the tag `airbyte/source-aha:dev`.




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-aha:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-aha:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-aha:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-aha:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-aha test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-aha test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/aha.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


pkgId: 10ed3dc301cb1aaae5d3e678ad5137384a700edd2bd83f9466e739c185a0954d
name: python-airbyte-source-aircall
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Source implementation for Aircall.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-aircall-0.3.0-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Aircall source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/aircall).




  * Python (~=3.9)
  * Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/aircall)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_aircall/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



  ```
  poetry run source-aircall spec
  poetry run source-aircall check --config secrets/config.json
  poetry run source-aircall discover --config secrets/config.json
  poetry run source-aircall read --config secrets/config.json --catalog sample_files/configured_catalog.json
  ```


  To run unit tests locally, from the connector directory run:
  ```
  poetry run pytest unit_tests
  ```


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-aircall build
  ```

  An image will be available on your host with the tag `airbyte/source-aircall:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-aircall:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-aircall:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-aircall:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-aircall:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```


  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-aircall test
  ```


  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.


  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.


  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-aircall test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/aircall.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


pkgId: 80a07365fe807af083bf0c389ff541a3e758c7d74175f7a0aba954b6a8e59ab4
name: python-airbyte-source-airtable
arch: src
version: 4.4.0
epoch: 0
release: 1
summary: Source implementation for Airtable.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-airtable-4.4.0-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Airtable source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/airtable).





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/airtable)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_airtable/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



  ```
  poetry run source-airtable spec
  poetry run source-airtable check --config secrets/config.json
  poetry run source-airtable discover --config secrets/config.json
  poetry run source-airtable read --config secrets/config.json --catalog sample_files/configured_catalog.json
  ```



  To run unit tests locally, from the connector directory run:

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

  ```bash
  airbyte-ci connectors --name=source-airtable build
  ```

  An image will be available on your host with the tag `airbyte/source-airtable:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-airtable:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-airtable:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-airtable:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-airtable:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-airtable test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-airtable test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/airtable.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


pkgId: 9d6baa1471eb267a6f7fc328df59625c3bef2adf252d21bbfb65179022c75779
name: python-airbyte-source-alpha-vantage
arch: src
version: 0.1.22
epoch: 0
release: 1
summary: Source implementation for Alpha Vantage.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-alpha-vantage-0.1.22-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Alpha-Vantage source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/alpha-vantage).




  * Python (~=3.9)
  * Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/alpha-vantage)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_alpha_vantage/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



  ```
  poetry run source-alpha-vantage spec
  poetry run source-alpha-vantage check --config secrets/config.json
  poetry run source-alpha-vantage discover --config secrets/config.json
  poetry run source-alpha-vantage read --config secrets/config.json --catalog sample_files/configured_catalog.json
  ```


  To run unit tests locally, from the connector directory run:
  ```
  poetry run pytest unit_tests
  ```


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-alpha-vantage build
  ```

  An image will be available on your host with the tag `airbyte/source-alpha-vantage:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-alpha-vantage:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-alpha-vantage:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-alpha-vantage:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-alpha-vantage:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```


  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-alpha-vantage test
  ```


  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.


  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.


  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-alpha-vantage test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/alpha-vantage.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


pkgId: 7c3959e3c9a2b20c34bec67c327ed051cd74ef377d2061ef2a6e430c2d48b76b
name: python-airbyte-source-amazon-ads
arch: src
version: 6.0.0
epoch: 0
release: 1
summary: Source implementation for Amazon Ads.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-amazon-ads-6.0.0-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Amazon-Ads source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/amazon-ads).





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/amazon-ads)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_amazon_ads/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



  ```
  poetry run source-amazon-ads spec
  poetry run source-amazon-ads check --config secrets/config.json
  poetry run source-amazon-ads discover --config secrets/config.json
  poetry run source-amazon-ads read --config secrets/config.json --catalog sample_files/configured_catalog.json
  ```



  To run unit tests locally, from the connector directory run:

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

  ```bash
  airbyte-ci connectors --name=source-amazon-ads build
  ```

  An image will be available on your host with the tag `airbyte/source-amazon-ads:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-amazon-ads:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-amazon-ads:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-amazon-ads:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-amazon-ads:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-amazon-ads test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-amazon-ads test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/amazon-ads.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


pkgId: 196b8d6d6778d6275e6b8a020addcb38585434b09b69dcfd9e20f3288377f9ca
name: python-airbyte-source-amazon-seller-partner
arch: src
version: 4.4.6
epoch: 0
release: 1
summary: Source implementation for Amazon Seller Partner.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-amazon-seller-partner-4.4.6-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Amazon Seller-Partner source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.io/integrations/sources/amazon-seller-partner).





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/amazon-seller-partner)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_amazon_seller_partner/spec.json` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `integration_tests/sample_config.json` for a sample config file.



  ```
  poetry run source-amazon-seller-partner spec
  poetry run source-amazon-seller-partner check --config secrets/config.json
  poetry run source-amazon-seller-partner discover --config secrets/config.json
  poetry run source-amazon-seller-partner read --config secrets/config.json --catalog integration_tests/configured_catalog.json
  ```



  To run unit tests locally, from the connector directory run:

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

  ```bash
  airbyte-ci connectors --name=source-amazon-seller-partner build
  ```

  An image will be available on your host with the tag `airbyte/source-amazon-seller-partner:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-amazon-seller-partner:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-amazon-seller-partner:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-amazon-seller-partner:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-amazon-seller-partner:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-amazon-seller-partner test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-amazon-seller-partner test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/amazon-seller-partner.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


pkgId: 0848f5a31980d41db79d1dcfcb937a3872415195491b9ffc32900a345b455c3b
name: python-airbyte-source-amplitude
arch: src
version: 0.6.13
epoch: 0
release: 1
summary: Source implementation for Amplitude.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-amplitude-0.6.13-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Amplitude source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/amplitude).





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/amplitude)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_amplitude/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



  ```
  poetry run source-amplitude spec
  poetry run source-amplitude check --config secrets/config.json
  poetry run source-amplitude discover --config secrets/config.json
  poetry run source-amplitude read --config secrets/config.json --catalog sample_files/configured_catalog.json
  ```



  To run unit tests locally, from the connector directory run:

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

  ```bash
  airbyte-ci connectors --name=source-amplitude build
  ```

  An image will be available on your host with the tag `airbyte/source-amplitude:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-amplitude:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-amplitude:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-amplitude:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-amplitude:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-amplitude test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-amplitude test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/amplitude.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


pkgId: 73c3eecdf038f56626ddcecf6eacd4b6494b168df40c08aa5d502c3d0e83bc70
name: python-airbyte-source-apify-dataset
arch: src
version: 2.1.27
epoch: 0
release: 1
summary: Source implementation for Apify Dataset.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-apify-dataset-2.1.27-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Apify-Dataset source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/apify-dataset).





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/apify-dataset)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_apify_dataset/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



  ```
  poetry run source-apify-dataset spec
  poetry run source-apify-dataset check --config secrets/config.json
  poetry run source-apify-dataset discover --config secrets/config.json
  poetry run source-apify-dataset read --config secrets/config.json --catalog sample_files/configured_catalog.json
  ```



  To run unit tests locally, from the connector directory run:

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

  ```bash
  airbyte-ci connectors --name=source-apify-dataset build
  ```

  An image will be available on your host with the tag `airbyte/source-apify-dataset:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-apify-dataset:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-apify-dataset:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-apify-dataset:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-apify-dataset:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-apify-dataset test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-apify-dataset test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/apify-dataset.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


