# packages

pkgId: c190cdca61f4dba0bcdfaaa43397980475756b752465b7230229a5dcfdf9c17d
name: python-aind-data-schema-models-help
arch: noarch
version: 0.7.1
epoch: 0
release: 1
summary: Development documents and examples for aind-data-schema-models
url: https://pypi.org/project/aind-data-schema-models/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aind-data-schema-models-0.7.1-1.src.rpm
location_href: Packages/python-aind-data-schema-models-help-0.7.1-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/license-MIT-brightgreen)](LICENSE)
  ![Code Style](https://img.shields.io/badge/code%20style-black-black)
  [![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
  ![Interrogate](https://img.shields.io/badge/interrogate-100.0%25-brightgreen)
  ![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen?logo=codecov)
  ![Python](https://img.shields.io/badge/python->=3.8-blue?logo=python)


  To install from pypi, run
  ```bash
  pip install aind-data-schema-models
  ```

  To install from source, in the root directory, run
  ```bash
  pip install -e .
  ```

  To develop the code, run
  ```bash
  pip install -e .[dev]
  ```





  The model class files, `brain_atlas.py` etc, are auto-generated. **You should never need to modify the class files directly.**

  Instead, take a look at the `jinja2` templates in the folder `_generators/templates`. The filename of the template is used to pull the corresponding `.csv` file and populate the `data` DataFrame. In the template you can pull data from the various columns and use them to populate each of the fields in your class.

  To re-build all the models, run the `run_all.sh` bash script in the root folder, which loops through the template files and runs them through the `generate_code` function.

  There are a few special cases, e.g. if data are missing in columns they will show up as `float: nan`. See the `organizations.txt` template for examples of how to handle this.



  There are several libraries used to run linters, check documentation, and run tests.

  - Please test your changes using the **coverage** library, which will run the tests and log a coverage report:

  ```bash
  coverage run -m unittest discover && coverage report
  ```

  - Use **interrogate** to check that modules, methods, etc. have been documented thoroughly:

  ```bash
  interrogate .
  ```

  - Use **flake8** to check that code is up to standards (no unused imports, etc.):
  ```bash
  flake8 .
  ```

  - Use **black** to automatically format the code into PEP standards:
  ```bash
  black .
  ```

  - Use **isort** to automatically sort import statements:
  ```bash
  isort .
  ```



  For internal members, please create a branch. For external members, please fork the repository and open a pull request from the fork. We'll primarily use [Angular](https://github.com/angular/angular/blob/main/CONTRIBUTING.md#commit) style for commit messages. Roughly, they should follow the pattern:
  ```text
  <type>(<scope>): <short summary>
  ```

  where scope (optional) describes the packages affected by the code changes and type (mandatory) is one of:

  - **build**: Changes that affect build tools or external dependencies (example scopes: pyproject.toml, setup.py)
  - **ci**: Changes to our CI configuration files and scripts (examples: .github/workflows/ci.yml)
  - **docs**: Documentation only changes
  - **feat**: A new feature
  - **fix**: A bugfix
  - **perf**: A code change that improves performance
  - **refactor**: A code change that neither fixes a bug nor adds a feature
  - **test**: Adding missing tests or correcting existing tests



  The table below, from [semantic release](https://github.com/semantic-release/semantic-release), shows which commit message gets you which release type when `semantic-release` runs (using the default configuration):

  | Commit message                                                                                                                                                                                   | Release type                                                                                                    |
  | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
  | `fix(pencil): stop graphite breaking when too much pressure applied`                                                                                                                             | ~~Patch~~ Fix Release, Default release                                                                          |
  | `feat(pencil): add 'graphiteWidth' option`                                                                                                                                                       | ~~Minor~~ Feature Release                                                                                       |
  | `perf(pencil): remove graphiteWidth option`<br><br>`BREAKING CHANGE: The graphiteWidth option has been removed.`<br>`The default graphite width of 10mm is always used for performance reasons.` | ~~Major~~ Breaking Release <br /> (Note that the `BREAKING CHANGE: ` token must be in the footer of the commit) |


  To generate the rst files source files for documentation, run
  ```bash
  sphinx-apidoc -o doc_template/source/ src
  ```
  Then to create the documentation HTML files, run
  ```bash
  sphinx-build -b html doc_template/source/ doc_template/build/html
  ```
  More info on sphinx installation can be found [here](https://www.sphinx-doc.org/en/master/usage/installation.html).


pkgId: 5f14ee44c259cc85ed624d3aa28f9a279ff814cae8c9d46b1fe44c8c1818fd64
name: python-aind-data-transfer-models-help
arch: noarch
version: 0.15.0
epoch: 0
release: 1
summary: Development documents and examples for aind-data-transfer-models
url: https://pypi.org/project/aind-data-transfer-models/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aind-data-transfer-models-0.15.0-1.src.rpm
location_href: Packages/python-aind-data-transfer-models-help-0.15.0-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/license-MIT-brightgreen)](LICENSE)
  ![Code Style](https://img.shields.io/badge/code%20style-black-black)
  [![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
  ![Interrogate](https://img.shields.io/badge/interrogate-100.0%25-brightgreen)
  ![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen?logo=codecov)
  ![Python](https://img.shields.io/badge/python->=3.9-blue?logo=python)





  For more detailed examples, please check out the [readthedocs](https://aind-data-transfer-service.readthedocs.io/en/latest/UserGuide.html#using-the-rest-api).


  - From pypi, run
  ```bash
  pip install aind-data-transfer-models
  ```
  - From git, in the root directory, run
  ```bash
  pip install -e .
  ```

  To develop the code, run
  ```bash
  pip install -e .[dev]
  ```





  There are several libraries used to run linters, check documentation, and run tests.

  - Please test your changes using the **coverage** library, which will run the tests and log a coverage report:

  ```bash
  coverage run -m unittest discover && coverage report
  ```

  - Use **interrogate** to check that modules, methods, etc. have been documented thoroughly:

  ```bash
  interrogate .
  ```

  - Use **flake8** to check that code is up to standards (no unused imports, etc.):
  ```bash
  flake8 .
  ```

  - Use **black** to automatically format the code into PEP standards:
  ```bash
  black .
  ```

  - Use **isort** to automatically sort import statements:
  ```bash
  isort .
  ```



  For internal members, please create a branch. For external members, please fork the repository and open a pull request from the fork. We'll primarily use [Angular](https://github.com/angular/angular/blob/main/CONTRIBUTING.md#commit) style for commit messages. Roughly, they should follow the pattern:
  ```text
  <type>(<scope>): <short summary>
  ```

  where scope (optional) describes the packages affected by the code changes and type (mandatory) is one of:

  - **build**: Changes that affect build tools or external dependencies (example scopes: pyproject.toml, setup.py)
  - **ci**: Changes to our CI configuration files and scripts (examples: .github/workflows/ci.yml)
  - **docs**: Documentation only changes
  - **feat**: A new feature
  - **fix**: A bugfix
  - **perf**: A code change that improves performance
  - **refactor**: A code change that neither fixes a bug nor adds a feature
  - **test**: Adding missing tests or correcting existing tests



  The table below, from [semantic release](https://github.com/semantic-release/semantic-release), shows which commit message gets you which release type when `semantic-release` runs (using the default configuration):

  | Commit message                                                                                                                                                                                   | Release type                                                                                                    |
  | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
  | `fix(pencil): stop graphite breaking when too much pressure applied`                                                                                                                             | ~~Patch~~ Fix Release, Default release                                                                          |
  | `feat(pencil): add 'graphiteWidth' option`                                                                                                                                                       | ~~Minor~~ Feature Release                                                                                       |
  | `perf(pencil): remove graphiteWidth option`<br><br>`BREAKING CHANGE: The graphiteWidth option has been removed.`<br>`The default graphite width of 10mm is always used for performance reasons.` | ~~Major~~ Breaking Release <br /> (Note that the `BREAKING CHANGE: ` token must be in the footer of the commit) |


pkgId: d50851ad0b6256121a93809dbd4ddb2864fc4776cddf77c15c28f5cab77d2c86
name: python-aind-metadata-mapper-help
arch: noarch
version: 0.22.0
epoch: 0
release: 1
summary: Development documents and examples for aind-metadata-mapper
url: https://pypi.org/project/aind-metadata-mapper/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aind-metadata-mapper-0.22.0-1.src.rpm
location_href: Packages/python-aind-metadata-mapper-help-0.22.0-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/license-MIT-brightgreen)](LICENSE)
  ![Code Style](https://img.shields.io/badge/code%20style-black-black)
  [![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
  ![Interrogate](https://img.shields.io/badge/interrogate-100.0%25-brightgreen)
  ![Coverage](https://img.shields.io/badge/coverage-86%25-yellow?logo=codecov)
  ![Python](https://img.shields.io/badge/python->=3.10-blue?logo=python)

  Repository to contain code that will parse source files into aind-data-schema models.




  To use the software, in the root directory, run
  ```bash
  pip install -e .[all]
  ```

  It's possible to install just a small subset of dependencies. For example,
  ```bash
  pip install -e .[bergamo]
  ```

  To develop the code, run
  ```bash
  pip install -e .[dev]
  ```


  If you've found a bug in the schemas or would like to make a minor change, open an [issue](https://github.com/AllenNeuralDynamics/aind-metadata-mapper/issues) and please use the provided templates. If you'd like to propose a large change or addition, or generally have a question about how things work, head start a new Discussion!


  Contributions are more than welcome for this project! If you'd like to develop the code, please follow the standards outlined in the [contribution guide](https://github.com/AllenNeuralDynamics/aind-metadata-mapper/blob/dev/CONTRIBUTING.md).


  To generate the rst files source files for documentation, run
  ```bash
  sphinx-apidoc -o docs/source/ src
  ```
  Then to create the documentation HTML files, run
  ```bash
  sphinx-build -b html docs/source/ docs/build/html
  ```
  More info on sphinx installation can be found [here](https://www.sphinx-doc.org/en/master/usage/installation.html).


  More information including a user guide and contributor guidelines can be found at [readthedocs](https://aind-metadata-mapper.readthedocs.io/en/latest/).


pkgId: 0ba46009ebac5740e46c2f6171a78ee9ad71d24fc9660817ea0a1399ab967c68
name: python-aind-mri-targeting-help
arch: noarch
version: 0.0.19
epoch: 0
release: 1
summary: Development documents and examples for aind-mri-targeting
url: https://pypi.org/project/aind-mri-targeting/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aind-mri-targeting-0.0.19-1.src.rpm
location_href: Packages/python-aind-mri-targeting-help-0.0.19-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/license-MIT-brightgreen)](LICENSE)
  ![Code Style](https://img.shields.io/badge/code%20style-black-black)
  [![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
  ![Interrogate](https://img.shields.io/badge/interrogate-46.2%25-red)
  ![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen?logo=codecov)
  ![Python](https://img.shields.io/badge/python->=3.7-blue?logo=python)



  To use the software, in the root directory, run
  ```bash
  pip install -e .
  ```

  To install notebooks, run
  ```bash
  install_notebooks [path]
  ```

  To develop the code, run
  ```bash
  pip install -e .[dev]
  ```





  There are several libraries used to run linters, check documentation, and run tests.

  - Please test your changes using the **coverage** library, which will run the tests and log a coverage report:

  ```bash
  coverage run -m unittest discover && coverage report
  ```

  - Use **interrogate** to check that modules, methods, etc. have been documented thoroughly:

  ```bash
  interrogate .
  ```

  - Use **flake8** to check that code is up to standards (no unused imports, etc.):
  ```bash
  flake8 .
  ```

  - Use **black** to automatically format the code into PEP standards:
  ```bash
  black .
  ```

  - Use **isort** to automatically sort import statements:
  ```bash
  isort .
  ```



  For internal members, please create a branch. For external members, please fork the repository and open a pull request from the fork. We'll primarily use [Angular](https://github.com/angular/angular/blob/main/CONTRIBUTING.md#commit) style for commit messages. Roughly, they should follow the pattern:
  ```text
  <type>(<scope>): <short summary>
  ```

  where scope (optional) describes the packages affected by the code changes and type (mandatory) is one of:

  - **build**: Changes that affect build tools or external dependencies (example scopes: pyproject.toml, setup.py)
  - **ci**: Changes to our CI configuration files and scripts (examples: .github/workflows/ci.yml)
  - **docs**: Documentation only changes
  - **feat**: A new feature
  - **fix**: A bugfix
  - **perf**: A code change that improves performance
  - **refactor**: A code change that neither fixes a bug nor adds a feature
  - **test**: Adding missing tests or correcting existing tests



  The table below, from [semantic release](https://github.com/semantic-release/semantic-release), shows which commit message gets you which release type when `semantic-release` runs (using the default configuration):

  | Commit message                                                                                                                                                                                   | Release type                                                                                                    |
  | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
  | `fix(pencil): stop graphite breaking when too much pressure applied`                                                                                                                             | ~~Patch~~ Fix Release, Default release                                                                          |
  | `feat(pencil): add 'graphiteWidth' option`                                                                                                                                                       | ~~Minor~~ Feature Release                                                                                       |
  | `perf(pencil): remove graphiteWidth option`<br><br>`BREAKING CHANGE: The graphiteWidth option has been removed.`<br>`The default graphite width of 10mm is always used for performance reasons.` | ~~Major~~ Breaking Release <br /> (Note that the `BREAKING CHANGE: ` token must be in the footer of the commit) |


  To generate the rst files source files for documentation, run
  ```bash
  sphinx-apidoc -o doc_template/source/ src
  ```
  Then to create the documentation HTML files, run
  ```bash
  sphinx-build -b html doc_template/source/ doc_template/build/html
  ```
  More info on sphinx installation can be found [here](https://www.sphinx-doc.org/en/master/usage/installation.html).


pkgId: 966d99912a3bb3289e69b222fdca8b310b21504ad02c057437c8e0c65d9badc5
name: python-aind-mri-utils-help
arch: noarch
version: 0.0.58
epoch: 0
release: 1
summary: Development documents and examples for aind-mri-utils
url: https://pypi.org/project/aind-mri-utils/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aind-mri-utils-0.0.58-1.src.rpm
location_href: Packages/python-aind-mri-utils-help-0.0.58-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/license-MIT-brightgreen)](LICENSE)
  ![Code Style](https://img.shields.io/badge/code%20style-black-black)
  [![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
  ![Interrogate](https://img.shields.io/badge/interrogate-94.9%25-brightgreen)
  ![Coverage](https://img.shields.io/badge/coverage-48%25-red?logo=codecov)
  ![Python](https://img.shields.io/badge/python->=3.7-blue?logo=python)

  Library for aind mri utilities.


  To use the software, in the root directory, run
  ```bash
  pip install -e .
  ```

  To develop the code, run
  ```bash
  pip install -e .[dev]
  ```





  There are several libraries used to run linters, check documentation, and run tests.

  - Please test your changes using the **coverage** library, which will run the tests and log a coverage report:

  ```bash
  coverage run -m unittest discover && coverage report
  ```

  - Use **interrogate** to check that modules, methods, etc. have been documented thoroughly:

  ```bash
  interrogate .
  ```

  - Use **flake8** to check that code is up to standards (no unused imports, etc.):
  ```bash
  flake8 .
  ```

  - Use **black** to automatically format the code into PEP standards:
  ```bash
  black .
  ```

  - Use **isort** to automatically sort import statements:
  ```bash
  isort .
  ```



  For internal members, please create a branch. For external members, please fork the repository and open a pull request from the fork. We'll primarily use [Angular](https://github.com/angular/angular/blob/main/CONTRIBUTING.md#commit) style for commit messages. Roughly, they should follow the pattern:
  ```text
  <type>(<scope>): <short summary>
  ```

  where scope (optional) describes the packages affected by the code changes and type (mandatory) is one of:

  - **build**: Changes that affect build tools or external dependencies (example scopes: pyproject.toml, setup.py)
  - **ci**: Changes to our CI configuration files and scripts (examples: .github/workflows/ci.yml)
  - **docs**: Documentation only changes
  - **feat**: A new feature
  - **fix**: A bugfix
  - **perf**: A code change that improves performance
  - **refactor**: A code change that neither fixes a bug nor adds a feature
  - **test**: Adding missing tests or correcting existing tests


  To generate the rst files source files for documentation, run
  ```bash
  sphinx-apidoc -o doc_template/source/ src
  ```
  Then to create the documentation HTML files, run
  ```bash
  sphinx-build -b html doc_template/source/ doc_template/build/html
  ```
  More info on sphinx installation can be found [here](https://www.sphinx-doc.org/en/master/usage/installation.html).


pkgId: 30504552d4a04c18c7eba6a75ff66184a1672795fb93f02471cdd079334bc44a
name: python-aiobotocore-help
arch: noarch
version: 2.16.0
epoch: 0
release: 1
summary: Development documents and examples for aiobotocore
url: https://pypi.org/project/aiobotocore/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiobotocore-2.16.0-1.src.rpm
location_href: Packages/python-aiobotocore-help-2.16.0-1.noarch.rpm
checksum_type: sha256
description:
  |ci badge| |pre-commit badge| |coverage badge| |docs badge| |pypi badge| |gitter badge| |pypi downloads badge| |conda badge| |stackoverflow badge|
  Async client for amazon services using botocore_ and aiohttp_/asyncio_.
  This library is a mostly full featured asynchronous version of botocore.


pkgId: e3ca540ad005cb7bf5c42d809a25891de410cf0db47e2c67eb42ac9fc275df13
name: python-aiogram-dialog-help
arch: noarch
version: 2.3.0
epoch: 0
release: 1
summary: Development documents and examples for aiogram-dialog
url: https://github.com/tishka17/aiogram_dialog
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiogram-dialog-2.3.0-1.src.rpm
location_href: Packages/python-aiogram-dialog-help-2.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/aiogram-dialog.svg)](https://badge.fury.io/py/aiogram-dialog)
  [![Doc](https://readthedocs.org/projects/aiogram-dialog/badge/?version=latest&style=flat)](https://aiogram-dialog.readthedocs.io)
  [![downloads](https://img.shields.io/pypi/dm/aiogram_dialog.svg)](https://pypistats.org/packages/aiogram_dialog)
  [![license](https://img.shields.io/github/license/Tishka17/aiogram_dialog.svg)](https://github.com/Tishka17/aiogram_dialog/blob/master/LICENSE)
  [![license](https://img.shields.io/badge/💬-Telegram-blue)](https://t.me/aiogram_dialog)


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


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

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

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

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

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

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


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




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



  Each window consists of:

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

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


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


  class MySG(StatesGroup):
      main = State()


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


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



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

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


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


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

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

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

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

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

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

  For example in `/start` command handler:

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

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

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


pkgId: 25f1782366a6704b07d179fa318513fc98a2e8db514c4efb8513dcbe4ea1c9ee
name: python-aiohomeconnect-help
arch: noarch
version: 0.7.1
epoch: 0
release: 1
summary: Development documents and examples for aiohomeconnect
url: https://github.com/MartinHjelmare/aiohomeconnect
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiohomeconnect-0.7.1-1.src.rpm
location_href: Packages/python-aiohomeconnect-help-0.7.1-1.noarch.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://aiohomeconnect.readthedocs.io" target="_blank">https://aiohomeconnect.readthedocs.io </a>


pkgId: cefa508b262bfac200c7651804b04b4be839517c2a5304a6c6b614374021073d
name: python-aiohttp-debuginfo
arch: aarch64
version: 3.11.11
epoch: 0
release: 1
summary: Debug information for package python-aiohttp
url: https://github.com/aio-libs/aiohttp
rpm_license: Apache-2.0
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-aiohttp-3.11.11-1.src.rpm
location_href: Packages/python-aiohttp-debuginfo-3.11.11-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-aiohttp.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 58eba5c3244521fa62b77965ac9d41b3a2097793716f310fbc9e02cb2216f6d9
name: python-aiohttp-debugsource
arch: aarch64
version: 3.11.11
epoch: 0
release: 1
summary: Debug sources for package python-aiohttp
url: https://github.com/aio-libs/aiohttp
rpm_license: Apache-2.0
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-aiohttp-3.11.11-1.src.rpm
location_href: Packages/python-aiohttp-debugsource-3.11.11-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-aiohttp.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: c36891fe5a621222db9278ad1fa990a2d74705843fc8d5a1ed85ea9cd61f93c4
name: python-aioli-sdk-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for aioli-sdk
url: https://github.com/determined-ai/aioli
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aioli-sdk-1.2.0-1.src.rpm
location_href: Packages/python-aioli-sdk-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  Aioli (**AI** **O**n**L**ine **I**nference) is a platform for deploying models a
  t scale.

  See [https://docs.determined.ai/](https://docs.determined.ai/) for more information.


pkgId: 9fd355044c6b2cec0a7cf0d4228733812e38128077fd50216519af5eae8895a5
name: python-aiolifx-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for aiolifx
url: http://github.com/aiolifx/aiolifx
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiolifx-1.1.2-1.src.rpm
location_href: Packages/python-aiolifx-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  aiolifx is a Python 3/asyncio library to control Lifx LED lightbulbs over your LAN.

  [![PyPI version fury.io](https://badge.fury.io/py/aiolifx.svg)](https://pypi.python.org/pypi/aiolifx)
  [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-licen)
  [![GITHUB-BADGE](https://github.com/aiolifx/aiolifx/workflows/black/badge.svg)](https://github.com/psf/black)
  [![Downloads](https://pepy.tech/badge/aiolifx/month)](https://pepy.tech/project/aiolifx)

  Most of it was taken from Meghan Clarkk lifxlan package (https://github.com/mclarkk)
  and adapted to Python 3 (and asyncio obviously)



  We are on PyPi so

       pip3 install aiolifx
  or
       python3 -m pip install aiolifx

  After installation, the utility

      aiolifx

  can be used to test/control devices.

  NOTE: When installing with Python 3.4, the installation produce an error message
        (syntax error). This can be safely ignored.




  Essentially, you create an object with at least 2 methods:

      - register
      - unregister

  You then start the LifxDiscovery task in asyncio. It will register any new light it finds.
  All the method communicating with the bulb can be passed a callback function to react to
  the bulb response. The callback should take 2 parameters:

      - a light object
      - the response message


  The easiest way is to look at the file in the examples directory. "Wifi" and "Uptime" use
  a callback to print the info when it is returned.


  In essence, the test program is this

      class bulbs():
      """ A simple class with a register and unregister methods
      """
          def __init__(self):
              self.bulbs=[]

          def register(self,bulb):
              self.bulbs.append(bulb)

          def unregister(self,bulb):
              idx=0
              for x in list([ y.mac_addr for y in self.bulbs]):
                  if x == bulb.mac_addr:
                      del(self.bulbs[idx])
                      break
                  idx+=1

      def readin():
      """Reading from stdin and displaying menu"""

          selection = sys.stdin.readline().strip("\n")
          DoSomething()

      MyBulbs = bulbs()
      loop = aio.get_event_loop()
      discovery = alix.LifxDiscovery(loop, MyBulbs)
      try:
          loop.add_reader(sys.stdin, readin)
          discovery.start()
          loop.run_forever()
      except:
          pass
      finally:
          discovery.cleanup()
          loop.remove_reader(sys.stdin)
          loop.close()


  Other things worth noting:

      -  Whilst LifxDiscovery uses UDP broadcast, the bulbs are
         connected with Unicast UDP

      - The socket connecting to a bulb is not closed unless the bulb is deemed to have
        gone the way of the Dodo. I've been using that for days with no problem

      - You can select to used IPv6 connection to the bulbs by passing an
        IPv6 prefix to LifxDiscovery. It's only been tried with /64 prefix.
        If you want to use a /48 prefix, add ":" (colon) at the end of the
        prefix and pray. (This means 2 colons at the end!)

      - I only have Original 1000, so I could not test with other types
        of bulbs

      - Unlike in lifxlan, set_waveform takes a dictionary with the right
        keys instead of all those parameters



  Run this command each time you make changes to the project. It enters at `__main__.py`

  ```bash
  pip3 install . && aiolifx
  ```



  Thanks to Anders Melchiorsen and Avi Miller for their essential contributions


pkgId: 1462bcb5d7610b823a274d904a0deee4b56a8f1ad5b3c56d3651588680c9e365
name: python-aiologic-help
arch: noarch
version: 0.12.0
epoch: 0
release: 1
summary: Development documents and examples for aiologic
url: https://pypi.org/project/aiologic/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiologic-0.12.0-1.src.rpm
location_href: Packages/python-aiologic-help-0.12.0-1.noarch.rpm
checksum_type: sha256
rpm_license:
  Copyright 2024 Ilya Egorov <0x42005e1f@gmail.com>.  Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


pkgId: 00e86e5bb1e621ec32b45cfe3b32f8625949c0fb3f99c134c2e70556889fb223
name: python-aioopenexchangerates-help
arch: noarch
version: 0.6.19
epoch: 0
release: 1
summary: Development documents and examples for aioopenexchangerates
url: https://github.com/MartinHjelmare/aioopenexchangerates
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aioopenexchangerates-0.6.19-1.src.rpm
location_href: Packages/python-aioopenexchangerates-help-0.6.19-1.noarch.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://aioopenexchangerates.readthedocs.io" target="_blank">https://aioopenexchangerates.readthedocs.io </a>


pkgId: e8c65db2be28b413afb58092f098f56ec6635a49cf76813b6d0416eccc2a88cb
name: python-aioretry-help
arch: noarch
version: 6.2.1
epoch: 0
release: 1
summary: Development documents and examples for aioretry
url: https://github.com/kaelzhang/python-aioretry
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aioretry-6.2.1-1.src.rpm
location_href: Packages/python-aioretry-help-6.2.1-1.noarch.rpm
checksum_type: sha256
description:
  [![](https://github.com/kaelzhang/python-aioretry/actions/workflows/python.yml/badge.svg)](https://github.com/kaelzhang/python-aioretry/actions/workflows/python.yml)
  [![](https://codecov.io/gh/kaelzhang/python-aioretry/branch/master/graph/badge.svg)](https://codecov.io/gh/kaelzhang/python-aioretry)
  [![](https://img.shields.io/pypi/v/aioretry.svg)](https://pypi.org/project/aioretry/)
  [![Conda version](https://img.shields.io/conda/vn/conda-forge/aioretry)](https://anaconda.org/conda-forge/aioretry)
  [![](https://img.shields.io/pypi/l/aioretry.svg)](https://github.com/kaelzhang/python-aioretry)



  Asyncio retry utility for Python 3.7+

  - [Upgrade guide](#upgrade-guide)



  ```sh
  $ pip install aioretry
  ```

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

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



  ```py
  import asyncio

  from aioretry import (
      retry,
      
      RetryPolicyStrategy,
      RetryInfo
  )


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


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

  asyncio.run(connect_to_server())
  ```



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

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

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



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

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

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

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

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



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

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

      @retry(
        retry_policy='_retry_policy',

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



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

      
      return False, 0

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





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

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



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

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

  ```py
  rt = retry_policy(info)

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

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

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

      return False, info.fails * 0.1
  ```



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



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



  2.x

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

      return True, 0.1 * fails
  ```

  5.x

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



  3.x

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

  5.x

  ```py

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



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



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

  ```py

  from datetime import datetime

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

      ...
  ```

  ```py

  import time

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

      ...
  ```



  [MIT](LICENSE)

rpm_license:
  Copyright (c) 2013 kaelzhang <>, contributors  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 25629b9437e88465091f586785c99ff72f4394dde7b9b4f9dcc16086e876958c
name: python-aiosqs-help
arch: noarch
version: 1.0.6
epoch: 0
release: 1
summary: Development documents and examples for aiosqs
url: https://github.com/d3QUone/aiosqs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiosqs-1.0.6-1.src.rpm
location_href: Packages/python-aiosqs-help-1.0.6-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/aiosqs.svg)](https://pypi.org/project/aiosqs/)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/aiosqs)



  Python asynchronous and lightweight SQS client. The goal of this library is to provide fast and optimal access to SQS
  for Python projects, e.g. when you need a high-load queue consumer or high-load queue producer written in Python.

  Supports Python versions 3.8, 3.9, 3.10, 3.11, 3.12.

  Supported and tested Amazon-like SQS providers: Amazon, VK Cloud.




  Main problem of `botocore` and `aiobotocore` is huge memory and CPU consumption.
  Also `aiobotocore` itself is a transition of `botocore` to async interface without any optimizations.

  Related issues:
  - https://github.com/boto/boto3/issues/1670
  - https://github.com/aio-libs/aiobotocore/issues/940
  - https://github.com/aio-libs/aiobotocore/issues/970




  ```shell
  pip install aiosqs
  ```




  Create a client:
  ```python
  from aiosqs import SQSClient

  client = SQSClient(
      aws_access_key_id="access_key_id",
      aws_secret_access_key="secret_access_key",
      region_name="us-west-2",
      host="sqs.us-west-2.amazonaws.com",
  )
  ```

  Receive the queue url by queue name:
  ```python
  response = await client.get_queue_url(queue_name=queue_name)
  queue_url = response["QueueUrl"]
  ```

  Send a message to the queue:
  ```python
  response = await client.send_message(
      queue_url=queue_url,
      message_body=json.dumps({"demo": 1, "key": "value"}),
      delay_seconds=0,
  )
  print(response)
  ```

  Receive a message from the queue:
  ```python
  response = await client.receive_message(
      queue_url=queue_url,
      max_number_of_messages=1,
      visibility_timeout=30,
  )
  if response:
      print(response)
      receipt_handle = response[0]["ReceiptHandle"]
  ```

  Delete the message from the queue:
  ```python
  await client.delete_message(
      queue_url=queue_url,
      receipt_handle=receipt_handle,
  )
  ```

  Close the client at the end:
  ```python
  await client.close()
  ```

  Another option is to use `SQSClient` as an async context manager. No need to call `close` manually in this case. Example:
  ```python
  from aiosqs import SQSClient

  async with SQSClient(
      aws_access_key_id="access_key_id",
      aws_secret_access_key="secret_access_key",
      region_name="us-west-2",
      host="sqs.us-west-2.amazonaws.com",
  ) as client:
      response = await client.get_queue_url(queue_name="dev_orders")
      queue_url = response["QueueUrl"]
      print(queue_url)
  ```


pkgId: ffff63b4ab666bd17c0c694bb8d1e9f76bc147291cb132f293dd7f48e6b7f1a2
name: python-aiostdlib-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for aiostdlib
url: https://github.com/syubogdanov/aiostdlib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiostdlib-0.1.0-1.src.rpm
location_href: Packages/python-aiostdlib-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI Version][shields/pypi/version]][pypi/homepage]
  [![PyPI Downloads][shields/pypi/downloads]][pypi/homepage]
  [![License][shields/pypi/license]][github/license]
  [![Python Version][shields/python/version]][pypi/homepage]

  > [!WARNING]
  > The library is in the pre-alpha stage.



  * Provides asynchronous version of the standard library;
  * The same API as the Python's standard, blocking API;
  * Blocking IO is performed in a separate thread.





  The library is available as [`aiostdlib`][pypi/homepage] on PyPI:

  ```shell
  pip install aiostdlib
  ```



  The `aiostdlib` API is the same as the standard library (*v3.13*), except that it is asynchronous.



  For more, see the [documentation][github/docs/builtins].

  ```python
  import asyncio

  from aiostdlib import builtins


  async def main() -> None:
      async with builtins.open("./aiostdlib.txt", mode="w") as file:
          await file.write("aiostdlib")


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



  For more, see the [documentation][github/docs/io].

  ```python
  import asyncio

  from aiostdlib import io


  async def main() -> None:
      async with io.open_code("aiostdlib.py") as file:
          data = await file.read()


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



  For more, see the [documentation][github/docs/json].

  ```python
  import asyncio

  from aiostdlib import builtins, json


  async def main() -> None:
      async with builtins.open("./aiostdlib.json", mode="w") as file:
          await json.dump(["aiostdlib"], file)


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



  For more, see the [documentation][github/docs/pathlib].

  ```python
  import asyncio

  from aiostdlib import pathlib


  async def main() -> None:
      path = pathlib.Path("./aiostdlib.txt")

      if not await path.exists():
          await path.write_text("aiostdlib")


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



  For more, see the [documentation][github/docs/shutil].

  ```python
  import asyncio

  from aiostdlib import shutil


  async def main() -> None:
      await shutil.rmtree("/tmp/aiostdlib/")


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



  For more, see the [documentation][github/docs/tarfile].

  ```python
  import asyncio

  from aiostdlib import tarfile


  async def main() -> None:
      if not await tarfile.is_tarfile("./aiostdlib.tar.gz"):
          detail = "The file is not a `tar` archive"
          raise RuntimeError(detail)


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



  For more, see the [documentation][github/docs/tempfile].

  ```python
  import asyncio

  from aiostdlib import tempfile


  async def main() -> None:
      tempdir, path = await asyncio.gather(
          tempfile.gettempdir(),
          tempfile.mkdtemp(),
      )

      if not path.startswith(tempdir):
          detail = "This is strange..."
          raise RuntimeError(detail)


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



  For more, see the [documentation][github/docs/tomllib].

  ```python
  import asyncio

  from aiostdlib import builtins, tomllib


  async def main() -> None:
      async with builtins.open("./aiostdlib.toml", mode="rb") as file:
          data = await tomllib.load(file)

          if "aiostdlib" not in data:
              detail = "Where is 'aiostdlib'?"
              raise RuntimeError(detail)


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



  For more, see the [documentation][github/docs/zipfile].

  ```python
  import asyncio

  from aiostdlib import zipfile


  async def main() -> None:
      if not await zipfile.is_zipfile("./aiostdlib.zip"):
          detail = "The file is not a `zip` archive"
          raise RuntimeError(detail)


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



  MIT License, Copyright (c) 2024 Sergei Bogdanov. See [LICENSE][github/license] file.

  <!-- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- -->

  [github/docs/builtins]: https://github.com/syubogdanov/aiostdlib/tree/main/docs/builtins.md
  [github/docs/io]: https://github.com/syubogdanov/aiostdlib/tree/main/docs/io.md
  [github/docs/json]: https://github.com/syubogdanov/aiostdlib/tree/main/docs/json.md
  [github/docs/pathlib]: https://github.com/syubogdanov/aiostdlib/tree/main/docs/pathlib.md
  [github/docs/shutil]: https://github.com/syubogdanov/aiostdlib/tree/main/docs/shutil.md
  [github/docs/tarfile]: https://github.com/syubogdanov/aiostdlib/tree/main/docs/tarfile.md
  [github/docs/tempfile]: https://github.com/syubogdanov/aiostdlib/tree/main/docs/tempfile.md
  [github/docs/tomllib]: https://github.com/syubogdanov/aiostdlib/tree/main/docs/tomllib.md
  [github/docs/zipfile]: https://github.com/syubogdanov/aiostdlib/tree/main/docs/zipfile.md
  [github/license]: https://github.com/syubogdanov/aiostdlib/tree/main/LICENSE

  [pypi/homepage]: https://pypi.org/project/aiostdlib/

  [shields/pypi/downloads]: https://img.shields.io/pypi/dm/aiostdlib.svg?color=green
  [shields/pypi/license]: https://img.shields.io/pypi/l/aiostdlib.svg?color=green
  [shields/pypi/version]: https://img.shields.io/pypi/v/aiostdlib.svg?color=green
  [shields/python/version]: https://img.shields.io/pypi/pyversions/aiostdlib.svg?color=green


pkgId: c6938671f3cc635800e17dc40e902070309b15f780e7002a443e9ee3420a896b
name: python-aioswitcher-help
arch: noarch
version: 5.1.1
epoch: 0
release: 1
summary: Development documents and examples for aioswitcher
url: https://pypi.org/project/aioswitcher/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aioswitcher-5.1.1-1.src.rpm
location_href: Packages/python-aioswitcher-help-5.1.1-1.noarch.rpm
checksum_type: sha256
description:
  [![gh-build-status]][7] [![gh-pages-status]][8] [![codecov]][3]

  PyPi module integrating with various [Switcher][12] devices.</br>
  Check out the [wiki pages][0] for a list of supported devices.

  ```shell
  pip install aioswitcher
  ```

  <table>
    <td><a href="https://aioswitcher.tomfi.info/">Documentation</a></td>
    <td><a href="https://github.com/TomerFi/aioswitcher/wiki">Wiki</a></td>
    <td><a href="https://github.com/TomerFi/aioswitcher/blob/dev/CONTRIBUTING.md">Contributing</a></td>
  </table>



  <details>
    <summary>State Bridge</summary>

  ```python
  async def print_devices(delay):
      def on_device_found_callback(device):
          
          print(asdict(device))

      async with SwitcherBridge(on_device_found_callback):
          await asyncio.sleep(delay)


  asyncio.run(print_devices(60))
  ```

  </details>

  <details>
    <summary>Power Plug API</summary>

    ```python
    async def control_power_plug(device_type, device_ip, device_id, device_key) :
        
        async with SwitcherApi(device_type, device_ip, device_id, device_key) as api:
            
            await api.get_state()
            
            await api.control_device(Command.ON)
            
            await api.control_device(Command.OFF)
            
            await api.set_device_name("my new name")

    asyncio.run(control_power_plug(DeviceType.POWER_PLUG, "111.222.11.22", "ab1c2d", "00"))
    ```

  </details>

  <details>
    <summary>Water Heater API</summary>

    ```python
    async def control_water_heater(device_type, device_ip, device_id, device_key) :
        
        async with SwitcherApi(device_type, device_ip, device_id, device_key) as api:
            
            await api.get_state()
            
            await api.control_device(Command.ON, 15)
            
            await api.control_device(Command.OFF)
            
            await api.set_device_name("my new name")
            
            await api.set_auto_shutdown(timedelta(hours=2, minutes=30))
            
            await api.get_schedules()
            
            await api.delete_schedule("1")
            
            
            await api.create_schedule("13:00", "14:30", {Days.SUNDAY, Days.FRIDAY})

    asyncio.run(control_water_heater(DeviceType.MINI, "111.222.11.22", "ab1c2d" , "00"))
    asyncio.run(control_water_heater(DeviceType.TOUCH, "111.222.11.22", "ab1c2d" , "00"))
    asyncio.run(control_water_heater(DeviceType.V2_ESP, "111.222.11.22", "ab1c2d" , "00"))
    asyncio.run(control_water_heater(DeviceType.V2_QCA, "111.222.11.22", "ab1c2d" , "00"))
    asyncio.run(control_water_heater(DeviceType.V4, "111.222.11.22", "ab1c2d" , "00"))
    ```

  </details>

  <details>
    <summary>Runner API</summary>

    ```python
    async def control_runner(device_type, device_ip, device_id, device_key, token) :
        
        async with SwitcherApi(device_type, device_ip, device_id, device_key, token) as api:
            
            await api.get_shutter_state(0)
            
            await api.set_position(30, 0)
            
            await api.stop_shutter(0)
            
            await api.set_light(DeviceState.ON, 0)
            
            await api.set_light(DeviceState.OFF, 0)

    asyncio.run(control_runner(DeviceType.RUNNER, "111.222.11.22", "ab1c2d", "00"))
    asyncio.run(control_runner(DeviceType.RUNNER_MINI, "111.222.11.22", "ab1c2d", "00"))
    asyncio.run(control_runner(DeviceType.RUNNER_S11, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    asyncio.run(control_runner(DeviceType.RUNNER_S12, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    ```

  </details>

  <details>
    <summary>Breeze API</summary>

    ```python
    async def control_breeze(device_type, device_ip, device_id, device_key, remote_manager, remote_id) :
        
        async with SwitcherApi(device_type, device_ip, device_id, device_key) as api:
            
            await api.get_breeze_state()
            
            remote = remote_manager.get_remote(remote_id)
            
            
            
            await api.control_breeze_device(
                remote,
                DeviceState.ON,
                ThermostatMode.COOL,
                24,
                ThermostatFanLevel.MEDIUM,
                ThermostatSwing.ON,
            )

    
    remote_manager = SwitcherBreezeRemoteManager()
    asyncio.run(control_breeze(DeviceType.BREEZE, "111.222.11.22", "ab1c2d", "00", remote_manager, "DLK65863"))
    ```

  </details>

  <details>
    <summary>Light API</summary>

    ```python
    async def control_light(device_type, device_ip, device_id, device_key, token) :
        
        async with SwitcherApi(device_type, device_ip, device_id, device_key, token) as api:
            
            await api.get_light_state(0)
            
            await api.set_light(DeviceState.ON, 0)
            
            await api.set_light(DeviceState.OFF, 0)

    asyncio.run(control_light(DeviceType.LIGHT_SL01, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    asyncio.run(control_light(DeviceType.LIGHT_SL01_MINI, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    asyncio.run(control_light(DeviceType.LIGHT_SL02, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    asyncio.run(control_light(DeviceType.LIGHT_SL02_MINI, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    asyncio.run(control_light(DeviceType.LIGHT_SL03, "111.222.11.22", "ab1c2d", "00", "zvVvd7JxtN7CgvkD1Psujw=="))
    ```

  </details>



  - [discover_devices.py](https://github.com/TomerFi/aioswitcher/blob/dev/scripts/discover_devices.py) can discover devices and their states (can be run by `poetry run discover_devices`).
  - [control_device.py](https://github.com/TomerFi/aioswitcher/blob/dev/scripts/control_device.py) can control a device (can be run by `poetry run control_device`).
  - [get_device_login_key.py](https://github.com/TomerFi/aioswitcher/blob/dev/scripts/get_device_login_key) can get a device login key (can be run by `poetry run get_device_login_key`).
  - [validate_token.py](https://github.com/TomerFi/aioswitcher/blob/dev/scripts/validate_token.py) can validate a device token which is a must for newer devices, used for communicating with devices (can be run by `poetry run validate_token`).



  This is **NOT** an official module and it is **NOT** officially supported by the vendor.</br>
  That said, thanks are in order to all the people at [Switcher][12] for their cooperation and general support.



  Thanks goes to these wonderful people ([emoji key][1]):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/aviadgolan"><img src="https://avatars.githubusercontent.com/u/17742111?v=4?s=100" width="100px;" alt="Aviad Golan"/><br /><sub><b>Aviad Golan</b></sub></a><br /><a href="#data-AviadGolan" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dolby360"><img src="https://avatars.githubusercontent.com/u/22151399?v=4?s=100" width="100px;" alt="Dolev Ben Aharon"/><br /><sub><b>Dolev Ben Aharon</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=dolby360" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://fabian-affolter.ch/blog/"><img src="https://avatars.githubusercontent.com/u/116184?v=4?s=100" width="100px;" alt="Fabian Affolter"/><br /><sub><b>Fabian Affolter</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=fabaff" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/oranja"><img src="https://avatars.githubusercontent.com/u/679184?v=4?s=100" width="100px;" alt="Itzik Ephraim"/><br /><sub><b>Itzik Ephraim</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=oranja" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Kesav890"><img src="https://avatars.githubusercontent.com/u/82559951?v=4?s=100" width="100px;" alt="Kesav890"/><br /><sub><b>Kesav890</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=Kesav890" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://liad.avrah.am"><img src="https://avatars.githubusercontent.com/u/7263223?v=4?s=100" width="100px;" alt="Liad Avraham"/><br /><sub><b>Liad Avraham</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=liadav" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/cdce8p"><img src="https://avatars.githubusercontent.com/u/30130371?v=4?s=100" width="100px;" alt="Marc Mueller"/><br /><sub><b>Marc Mueller</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=cdce8p" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/OrBin"><img src="https://avatars.githubusercontent.com/u/6897234?v=4?s=100" width="100px;" alt="Or Bin"/><br /><sub><b>Or Bin</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=OrBin" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/5c077m4n"><img src="https://avatars.githubusercontent.com/u/35409124?v=4?s=100" width="100px;" alt="Roeeeee"/><br /><sub><b>Roeeeee</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=5c077m4n" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://exploit.co.il"><img src="https://avatars.githubusercontent.com/u/1768915?v=4?s=100" width="100px;" alt="Shai rod"/><br /><sub><b>Shai rod</b></sub></a><br /><a href="#data-nightrang3r" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/thecode"><img src="https://avatars.githubusercontent.com/u/1858925?v=4?s=100" width="100px;" alt="Shay Levy"/><br /><sub><b>Shay Levy</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=thecode" title="Code">💻</a> <a href="#ideas-thecode" title="Ideas, Planning, & Feedback">🤔</a> <a href="#maintenance-thecode" title="Maintenance">🚧</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/YogevBokobza"><img src="https://avatars.githubusercontent.com/u/22839127?v=4?s=100" width="100px;" alt="YogevBokobza"/><br /><sub><b>YogevBokobza</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=YogevBokobza" title="Code">💻</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=YogevBokobza" title="Tests">⚠️</a> <a href="#maintenance-YogevBokobza" title="Maintenance">🚧</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/gmyuval"><img src="https://avatars.githubusercontent.com/u/28506179?v=4?s=100" width="100px;" alt="Yuval Moran"/><br /><sub><b>Yuval Moran</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=gmyuval" title="Code">💻</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=gmyuval" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ayal"><img src="https://avatars.githubusercontent.com/u/121446?v=4?s=100" width="100px;" alt="ayal"/><br /><sub><b>ayal</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/issues?q=author%3Aayal" title="Bug reports">🐛</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=ayal" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dmatik"><img src="https://avatars.githubusercontent.com/u/5577386?v=4?s=100" width="100px;" alt="dmatik"/><br /><sub><b>dmatik</b></sub></a><br /><a href="#blog-dmatik" title="Blogposts">📝</a> <a href="#ideas-dmatik" title="Ideas, Planning, & Feedback">🤔</a> <a href="#userTesting-dmatik" title="User Testing">📓</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/epenet"><img src="https://avatars.githubusercontent.com/u/6771947?v=4?s=100" width="100px;" alt="epenet"/><br /><sub><b>epenet</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/issues?q=author%3Aepenet" title="Bug reports">🐛</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=epenet" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jafar-atili"><img src="https://avatars.githubusercontent.com/u/19508787?v=4?s=100" width="100px;" alt="jafar-atili"/><br /><sub><b>jafar-atili</b></sub></a><br /><a href="https://github.com/TomerFi/aioswitcher/commits?author=jafar-atili" title="Code">💻</a> <a href="https://github.com/TomerFi/aioswitcher/commits?author=jafar-atili" title="Documentation">📖</a></td>
      </tr>
    </tbody>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  <!-- Real Links -->
  [0]: https://github.com/TomerFi/aioswitcher/wiki
  [1]: https://allcontributors.org/docs/en/emoji-key
  [2]: https://allcontributors.org
  [3]: https://codecov.io/gh/TomerFi/aioswitcher
  [4]: https://github.com/TomerFi/aioswitcher
  [7]: https://github.com/TomerFi/aioswitcher/actions/workflows/stage.yml
  [8]: https://aioswitcher.tomfi.info/
  [11]: https://pypi.org/project/aioswitcher
  [12]: https://www.switcher.co.il/
  <!-- Badges Links -->
  [all-contributors]: https://img.shields.io/github/all-contributors/tomerfi/aioswitcher?color=ee8449&style=flat-square
  [codecov]: https://codecov.io/gh/TomerFi/aioswitcher/graph/badge.svg
  [gh-build-status]: https://github.com/TomerFi/aioswitcher/actions/workflows/stage.yml/badge.svg
  [gh-pages-status]: https://github.com/TomerFi/aioswitcher/actions/workflows/pages.yml/badge.svg
  [license-badge]: https://img.shields.io/github/license/tomerfi/aioswitcher
  [pypi-downloads]: https://img.shields.io/pypi/dm/aioswitcher.svg?logo=pypi&color=1082C2
  [pypi-version]: https://img.shields.io/pypi/v/aioswitcher?logo=pypi


pkgId: 8c035953a4c4f6b2c7fbe5f35703e42386621ea8e33e9c6fd50ed0d32f3c360b
name: python-aiovantage-help
arch: noarch
version: 0.16.0
epoch: 0
release: 1
summary: Development documents and examples for aiovantage
url: https://pypi.org/project/aiovantage/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiovantage-0.16.0-1.src.rpm
location_href: Packages/python-aiovantage-help-0.16.0-1.noarch.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)                |
  | BackBox       | Backboxes             | `vantage.backboxes`           |                                           |
  | 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)         |
  | PortDevice    | Port devices (hubs)   | `vantage.port_devices`        |                                           |
  | 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: 37ce5c086a9d5b46672b366d1e6e47a61c1e4bd25ad715f14e5b8498565a34b5
name: python-airavata-python-sdk-test-help
arch: noarch
version: 0.0.6.post3
epoch: 0
release: 1
summary: Development documents and examples for airavata-python-sdk-test
url: https://pypi.org/project/airavata-python-sdk-test/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airavata-python-sdk-test-0.0.6.post3-1.src.rpm
location_href: Packages/python-airavata-python-sdk-test-help-0.0.6.post3-1.noarch.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: e147e2b3c876403c6a729abc727d2565fa5229df995f28bfd44e9e100440200e
name: python-airbyte-cdk-help
arch: noarch
version: 6.11.1
epoch: 0
release: 1
summary: Development documents and examples for airbyte-cdk
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-cdk-6.11.1-1.src.rpm
location_href: Packages/python-airbyte-cdk-help-6.11.1-1.noarch.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: 69a36bbafbbeca99d9bc917d47acedec43dce8e3602ac1e2c114d93ed5db1637
name: python-airbyte-help
arch: noarch
version: 0.22.0
epoch: 0
release: 1
summary: Development documents and examples for airbyte
url: https://pypi.org/project/airbyte/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-0.22.0-1.src.rpm
location_href: Packages/python-airbyte-help-0.22.0-1.noarch.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: 3f07d0a64ebc9e5b62602777cee2e24bd9f4d2de4014f35bdcadf5603eff1573
name: python-airbyte-source-adjust-help
arch: noarch
version: 0.1.26
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-adjust
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-adjust-0.1.26-1.src.rpm
location_href: Packages/python-airbyte-source-adjust-help-0.1.26-1.noarch.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: d98327ef1ff57c2166b6bf10213009ec70b0b9700924a564f4b2993df4f478c6
name: python-airbyte-source-alpha-vantage-help
arch: noarch
version: 0.1.23
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-alpha-vantage
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-alpha-vantage-0.1.23-1.src.rpm
location_href: Packages/python-airbyte-source-alpha-vantage-help-0.1.23-1.noarch.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: aa9a12094a1c87e6caec26df50a04d899df33d4a6aac76313085e629be564900
name: python-airbyte-source-amazon-ads-help
arch: noarch
version: 6.2.1
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-amazon-ads
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-amazon-ads-6.2.1-1.src.rpm
location_href: Packages/python-airbyte-source-amazon-ads-help-6.2.1-1.noarch.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: 4fff21cac4b561f22a65c89c1c0d16366c0cd6b3807f03feb9a161f8a8ae56ec
name: python-airbyte-source-amplitude-help
arch: noarch
version: 0.6.14
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-amplitude
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-amplitude-0.6.14-1.src.rpm
location_href: Packages/python-airbyte-source-amplitude-help-0.6.14-1.noarch.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: 915f0e88d080854ff6aa494298c024a3e837706617f62157ef6d5d078f8d496a
name: python-airbyte-source-appsflyer-help
arch: noarch
version: 0.2.23
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-appsflyer
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-appsflyer-0.2.23-1.src.rpm
location_href: Packages/python-airbyte-source-appsflyer-help-0.2.23-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Appsflyer source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/appsflyer).




  * 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/appsflyer)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_appsflyer/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-appsflyer spec
  poetry run source-appsflyer check --config secrets/config.json
  poetry run source-appsflyer discover --config secrets/config.json
  poetry run source-appsflyer 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-appsflyer build
  ```

  An image will be available on your host with the tag `airbyte/source-appsflyer:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-appsflyer:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-appsflyer:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-appsflyer:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-appsflyer: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-appsflyer 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-appsflyer 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/appsflyer.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: 52eb18e17b82ebb18399cc3148bc1d982d6367d1a84717873f1f5121370ad26e
name: python-airbyte-source-asana-help
arch: noarch
version: 1.3.1
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-asana
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-asana-1.3.1-1.src.rpm
location_href: Packages/python-airbyte-source-asana-help-1.3.1-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Asana configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/asana).





  * 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/asana)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `spec` inside `manifest.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 `integration_tests/sample_config.json` for a sample config file.





  ```
  poetry run source-asana spec
  poetry run source-asana check --config secrets/config.json
  poetry run source-asana discover --config secrets/config.json
  poetry run source-asana 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-asana build
  ```

  An image will be available on your host with the tag `airbyte/source-asana:dev`.




  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-asana:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-asana:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-asana:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-asana: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-asana 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-asana 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/asana.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: db3d92da38efb0b35eb6c9c58287f3751157e5489842a519bc063f48e15a0c8d
name: python-airbyte-source-azure-table-help
arch: noarch
version: 0.1.30
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-azure-table
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-azure-table-0.1.30-1.src.rpm
location_href: Packages/python-airbyte-source-azure-table-help-0.1.30-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Azure-Table source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/azure-table).




  * 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/azure-table)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_azure_table/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-azure-table spec
  poetry run source-azure-table check --config secrets/config.json
  poetry run source-azure-table discover --config secrets/config.json
  poetry run source-azure-table 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-azure-table build
  ```

  An image will be available on your host with the tag `airbyte/source-azure-table:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-azure-table:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-azure-table:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-azure-table:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-azure-table: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-azure-table 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-azure-table 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/azure-table.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: b226e8f7a1a42cbe49a4b9dceb82c893b1cf5cf262cbd2f3310b0ce312612e7e
name: python-airbyte-source-bing-ads-help
arch: noarch
version: 2.8.5
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-bing-ads
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-bing-ads-2.8.5-1.src.rpm
location_href: Packages/python-airbyte-source-bing-ads-help-2.8.5-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Bing-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/bing-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/bing-ads)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_bing_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-bing-ads spec
  poetry run source-bing-ads check --config secrets/config.json
  poetry run source-bing-ads discover --config secrets/config.json
  poetry run source-bing-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-bing-ads build
  ```

  An image will be available on your host with the tag `airbyte/source-bing-ads:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-bing-ads:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-bing-ads:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-bing-ads:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-bing-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-bing-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-bing-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/bing-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: a485aec61a42a17f5b81070978e362041f86e83b4120381609a2a5d95db369de
name: python-airbyte-source-braintree-help
arch: noarch
version: 0.3.23
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-braintree
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-braintree-0.3.23-1.src.rpm
location_href: Packages/python-airbyte-source-braintree-help-0.3.23-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Braintree source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.io/integrations/sources/braintree).




  * 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.io/integrations/sources/braintree)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_braintree/spec.json` file.
  Note that the `secrets` directory is gitignored by default, so there is no danger of accidentally checking in sensitive information.
  See `integration_tests/sample_config.json` for a sample config file.

  **If you are an Airbyte core member**, copy the credentials in Lastpass under the secret name `source braintree test creds`
  and place them into `secrets/config.json`.



  ```
  poetry run source-braintree spec
  poetry run source-braintree check --config secrets/config.json
  poetry run source-braintree discover --config secrets/config.json
  poetry run source-braintree read --config secrets/config.json --catalog sample_files/configured_catalog.json
  ```


  To run unit tests locally, from the connector directory run:
  ```
  poetry run pytest
  ```





  **Via [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md) (recommended):**

  ```bash
  airbyte-ci connectors --name=source-braintree build
  ```

  An image will be built with the tag `airbyte/source-braintree:dev`.




  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-braintree:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-braintree:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-braintree:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-braintree: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-braintree test
  ```



  Customize `acceptance-test-config.yml` file to configure 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-braintree 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 the connector documentation and its changelog is up to date (`docs/integrations/sources/braintree.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: a9789e1cf9270402307772c4cadf8fb2d19772691ddc029e38fb8ba1c1d4d0de
name: python-airbyte-source-cart-help
arch: noarch
version: 0.3.9
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-cart
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-cart-0.3.9-1.src.rpm
location_href: Packages/python-airbyte-source-cart-help-0.3.9-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Cart source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/cart).





  - 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/cart)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_cart/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-cart spec
  poetry run source-cart check --config secrets/config.json
  poetry run source-cart discover --config secrets/config.json
  poetry run source-cart 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-cart build
  ```

  An image will be available on your host with the tag `airbyte/source-cart:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-cart:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-cart:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-cart:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-cart: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-cart 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-cart 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/cart.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: 0147b7375735e89c18ca2337eeabea2c754e7fd3fa8bf720efd6826d8a38c91a
name: python-airbyte-source-close-com-help
arch: noarch
version: 0.5.26
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-close-com
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-close-com-0.5.26-1.src.rpm
location_href: Packages/python-airbyte-source-close-com-help-0.5.26-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Close-Com source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/close-com).




  * 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/close-com)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_close_com/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-close-com spec
  poetry run source-close-com check --config secrets/config.json
  poetry run source-close-com discover --config secrets/config.json
  poetry run source-close-com 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-close-com build
  ```

  An image will be available on your host with the tag `airbyte/source-close-com:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-close-com:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-close-com:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-close-com:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-close-com: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-close-com 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-close-com 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/close-com.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: ccab0ff38ecd59ce5d090ee87b40ad78a74438103519daf91965ee04159f4762
name: python-airbyte-source-commcare-help
arch: noarch
version: 0.1.24
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-commcare
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-commcare-0.1.24-1.src.rpm
location_href: Packages/python-airbyte-source-commcare-help-0.1.24-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Commcare source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/commcare).




  * 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/commcare)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_commcare/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-commcare spec
  poetry run source-commcare check --config secrets/config.json
  poetry run source-commcare discover --config secrets/config.json
  poetry run source-commcare 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-commcare build
  ```

  An image will be available on your host with the tag `airbyte/source-commcare:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-commcare:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-commcare:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-commcare:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-commcare: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-commcare 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-commcare 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/commcare.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: 112ae1669119a80e0cca9851039528611bf8594825c30a1851a323a8b1c4bfea
name: python-airbyte-source-convex-help
arch: noarch
version: 0.4.23
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-convex
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-convex-0.4.23-1.src.rpm
location_href: Packages/python-airbyte-source-convex-help-0.4.23-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Convex source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/convex).




  * 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/convex)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_convex/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-convex spec
  poetry run source-convex check --config secrets/config.json
  poetry run source-convex discover --config secrets/config.json
  poetry run source-convex 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-convex build
  ```

  An image will be available on your host with the tag `airbyte/source-convex:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-convex:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-convex:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-convex:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-convex: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-convex 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-convex 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/convex.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: e308e113c3d93525cc2a06cabf36bb29cbc7266137d7300847b99b0e215d9b13
name: python-airbyte-source-facebook-marketing-help
arch: noarch
version: 3.3.21
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-facebook-marketing
url: https://airbyte.com
rpm_license: ELv2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-facebook-marketing-3.3.21-1.src.rpm
location_href: Packages/python-airbyte-source-facebook-marketing-help-3.3.21-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Facebook-Marketing source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/facebook-marketing).





  - 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/facebook-marketing)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_facebook_marketing/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-facebook-marketing spec
  poetry run source-facebook-marketing check --config secrets/config.json
  poetry run source-facebook-marketing discover --config secrets/config.json
  poetry run source-facebook-marketing 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-facebook-marketing build
  ```

  An image will be available on your host with the tag `airbyte/source-facebook-marketing:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-facebook-marketing:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-facebook-marketing:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-facebook-marketing:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-facebook-marketing: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-facebook-marketing 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-facebook-marketing 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/facebook-marketing.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: 21ed625c4214b8d994c0ab27a129f2ac072bea0776fb1c6e6387f1c160248f91
name: python-airbyte-source-facebook-pages-help
arch: noarch
version: 1.0.24
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-facebook-pages
url: https://airbyte.com
rpm_license: ELv2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-facebook-pages-1.0.24-1.src.rpm
location_href: Packages/python-airbyte-source-facebook-pages-help-1.0.24-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Facebook Pages configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.io/integrations/sources/facebook-pages).





  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.io/integrations/sources/facebook-pages)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_facebook_pages/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 `integration_tests/sample_config.json` for a sample config file.

  **If you are an Airbyte core member**, copy the credentials in Lastpass under the secret name `source facebook-pages test creds`
  and place them into `secrets/config.json`.





  The Airbyte way of building this connector is to use our `airbyte-ci` tool.
  You can follow install instructions [here](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md#L1).
  Then running the following command will build your connector:

  ```bash
  airbyte-ci connectors --name source-facebook-pages build
  ```

  Once the command is done, you will find your connector image in your local docker registry: `airbyte/source-facebook-pages:dev`.



  When contributing on our connector you might need to customize the build process to add a system dependency or set an env var.
  You can customize our build process by adding a `build_customization.py` module to your connector.
  This module should contain a `pre_connector_install` and `post_connector_install` async function that will mutate the base image and the connector container respectively.
  It will be imported at runtime by our build process and the functions will be called if they exist.

  Here is an example of a `build_customization.py` module:

  ```python
  from __future__ import annotations

  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      
      
      from dagger import Container


  async def pre_connector_install(base_image_container: Container) -> Container:
      return await base_image_container.with_env_variable("MY_PRE_BUILD_ENV_VAR", "my_pre_build_env_var_value")

  async def post_connector_install(connector_container: Container) -> Container:
      return await connector_container.with_env_variable("MY_POST_BUILD_ENV_VAR", "my_post_build_env_var_value")
  ```



  This connector is built using our dynamic built process in `airbyte-ci`.
  The base image used to build it is defined within the metadata.yaml file under the `connectorBuildOptions`.
  The build logic is defined using [Dagger](https://dagger.io/) [here](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/pipelines/builds/python_connectors.py).
  It does not rely on a Dockerfile.

  If you would like to patch our connector and build your own a simple approach would be to:

  1. Create your own Dockerfile based on the latest version of the connector image.

  ```Dockerfile
  FROM airbyte/source-facebook-pages:latest

  COPY . ./airbyte/integration_code
  RUN pip install ./airbyte/integration_code




  ```

  Please use this as an example. This is not optimized.

  2. Build your image:

  ```bash
  docker build -t airbyte/source-facebook-pages:dev .

  docker run airbyte/source-facebook-pages:dev spec
  ```



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-facebook-pages:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-facebook-pages:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-facebook-pages:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-facebook-pages: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-facebook-pages test
  ```



  Customize `acceptance-test-config.yml` file to configure 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 go in `setup.py`, NOT `requirements.txt`. The requirements file is only used to connect internal Airbyte dependencies in the monorepo for local development.
  We split dependencies between two groups, dependencies that are:

  - required for your connector to work need to go to `MAIN_REQUIREMENTS` list.
  - required for the testing need to go to `TEST_REQUIREMENTS` list



  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-facebook-pages test`
  2. Bump the connector version in `metadata.yaml`: increment the `dockerImageTag` value. Please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors).
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make the connector documentation and its changelog is up to date (`docs/integrations/sources/facebook-pages.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.


pkgId: 61eeb1e87234456693f0794a6d46516e5ee8b440e4dddc356a634c3a0b29d01f
name: python-airbyte-source-firebase-realtime-database-help
arch: noarch
version: 0.1.28
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-firebase-realtime-database
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-firebase-realtime-database-0.1.28-1.src.rpm
location_href: Packages/python-airbyte-source-firebase-realtime-database-help-0.1.28-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Firebase-Realtime-Database source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/firebase-realtime-database).




  * 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/firebase-realtime-database)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_firebase_realtime_database/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-firebase-realtime-database spec
  poetry run source-firebase-realtime-database check --config secrets/config.json
  poetry run source-firebase-realtime-database discover --config secrets/config.json
  poetry run source-firebase-realtime-database 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-firebase-realtime-database build
  ```

  An image will be available on your host with the tag `airbyte/source-firebase-realtime-database:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-firebase-realtime-database:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-firebase-realtime-database:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-firebase-realtime-database:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-firebase-realtime-database: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-firebase-realtime-database 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-firebase-realtime-database 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/firebase-realtime-database.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: 924301ff0845163963edc0bec016310585ad80e86ce702cf5b2fec4460f24133
name: python-airbyte-source-genesys-help
arch: noarch
version: 0.1.24
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-genesys
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-genesys-0.1.24-1.src.rpm
location_href: Packages/python-airbyte-source-genesys-help-0.1.24-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Genesys source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/genesys).




  * 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/genesys)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_genesys/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-genesys spec
  poetry run source-genesys check --config secrets/config.json
  poetry run source-genesys discover --config secrets/config.json
  poetry run source-genesys 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-genesys build
  ```

  An image will be available on your host with the tag `airbyte/source-genesys:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-genesys:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-genesys:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-genesys:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-genesys: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-genesys 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-genesys 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/genesys.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: c5d9f4480022242194afdcc555c4c9492aa7fdb22745d46239251da82b4cb866
name: python-airbyte-source-github-help
arch: noarch
version: 1.8.18
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-github
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-github-1.8.18-1.src.rpm
location_href: Packages/python-airbyte-source-github-help-1.8.18-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Github source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/github).





  - 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/github)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_github/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-github spec
  poetry run source-github check --config secrets/config.json
  poetry run source-github discover --config secrets/config.json
  poetry run source-github 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-github build
  ```

  An image will be available on your host with the tag `airbyte/source-github:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-github:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-github:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-github:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-github: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-github 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-github 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/github.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: f9ca8001680deeb4957df6e1de4da3fda570aa2b615c039ef1fd6f71febaf376
name: python-airbyte-source-google-analytics-data-api-help
arch: noarch
version: 2.6.2
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-google-analytics-data-api
url: https://airbyte.com
rpm_license: Elv2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-google-analytics-data-api-2.6.2-1.src.rpm
location_href: Packages/python-airbyte-source-google-analytics-data-api-help-2.6.2-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Google-Analytics-Data-Api source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/google-analytics-data-api).





  - 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/google-analytics-data-api)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_google_analytics_data_api/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-google-analytics-data-api spec
  poetry run source-google-analytics-data-api check --config secrets/config.json
  poetry run source-google-analytics-data-api discover --config secrets/config.json
  poetry run source-google-analytics-data-api 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-google-analytics-data-api build
  ```

  An image will be available on your host with the tag `airbyte/source-google-analytics-data-api:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-google-analytics-data-api:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-google-analytics-data-api:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-google-analytics-data-api:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-google-analytics-data-api: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-google-analytics-data-api 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-google-analytics-data-api 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/google-analytics-data-api.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: e624e9ab4960307bd6bb5d99f6e0da85225deacdd38ec22a846cbc5c114d94b3
name: python-airbyte-source-google-directory-help
arch: noarch
version: 0.2.25
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-google-directory
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-google-directory-0.2.25-1.src.rpm
location_href: Packages/python-airbyte-source-google-directory-help-0.2.25-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Google-Directory source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/google-directory).




  * 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/google-directory)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_google_directory/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-google-directory spec
  poetry run source-google-directory check --config secrets/config.json
  poetry run source-google-directory discover --config secrets/config.json
  poetry run source-google-directory 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-google-directory build
  ```

  An image will be available on your host with the tag `airbyte/source-google-directory:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-google-directory:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-google-directory:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-google-directory:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-google-directory: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-google-directory 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-google-directory 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/google-directory.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: fcc219efc167e555c3e9ea1fb6c6cb67e1dd60af23e62d275c516390d04c2f88
name: python-airbyte-source-google-search-console-help
arch: noarch
version: 1.5.6
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-google-search-console
url: https://airbyte.com
rpm_license: Elv2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-google-search-console-1.5.6-1.src.rpm
location_href: Packages/python-airbyte-source-google-search-console-help-1.5.6-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Google-Search-Console source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/google-search-console).





  - 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/google-search-console)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_google_search_console/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-google-search-console spec
  poetry run source-google-search-console check --config secrets/config.json
  poetry run source-google-search-console discover --config secrets/config.json
  poetry run source-google-search-console 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-google-search-console build
  ```

  An image will be available on your host with the tag `airbyte/source-google-search-console:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-google-search-console:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-google-search-console:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-google-search-console:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-google-search-console: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-google-search-console 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-google-search-console 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/google-search-console.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: e8ce697338473038d0900e501ca8747feaa4442c1b2aa0b448f31a0e0aac00eb
name: python-airbyte-source-greenhouse-help
arch: noarch
version: 0.5.27
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-greenhouse
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-greenhouse-0.5.27-1.src.rpm
location_href: Packages/python-airbyte-source-greenhouse-help-0.5.27-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Greenhouse source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/greenhouse).





  - 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/greenhouse)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `spec` inside `source_greenhouse/manifest.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 `integration_tests/sample_config.json` for a sample config file.



  ```
  poetry run source-greenhouse spec
  poetry run source-greenhouse check --config secrets/config.json
  poetry run source-greenhouse discover --config secrets/config.json
  poetry run source-greenhouse 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-greenhouse build
  ```

  An image will be available on your host with the tag `airbyte/source-greenhouse:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-greenhouse:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-greenhouse:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-greenhouse:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-greenhouse: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-greenhouse 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-greenhouse 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/greenhouse.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: 8bf80471a19cf19d52e0901b0c1f2b5a6e62c0a6388dd5b046f46ec895e0e8b1
name: python-airbyte-source-gridly-help
arch: noarch
version: 0.1.24
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-gridly
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-gridly-0.1.24-1.src.rpm
location_href: Packages/python-airbyte-source-gridly-help-0.1.24-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Gridly source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/gridly).




  * 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/gridly)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_gridly/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-gridly spec
  poetry run source-gridly check --config secrets/config.json
  poetry run source-gridly discover --config secrets/config.json
  poetry run source-gridly 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-gridly build
  ```

  An image will be available on your host with the tag `airbyte/source-gridly:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-gridly:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-gridly:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-gridly:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-gridly: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-gridly 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-gridly 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/gridly.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: eb5317ed536f75a510a581c8cdc31e4711c9a2726cd0f60c0e8a1161b94abe58
name: python-airbyte-source-hardcoded-records-help
arch: noarch
version: 0.0.20
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-hardcoded-records
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-hardcoded-records-0.0.20-1.src.rpm
location_href: Packages/python-airbyte-source-hardcoded-records-help-0.0.20-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Hardcoded Records source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/hardcoded-records).





  - 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/hardcoded-records)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_hardcoded_records/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-hardcoded-records spec
  poetry run source-hardcoded-records check --config secrets/config.json
  poetry run source-hardcoded-records discover --config secrets/config.json
  poetry run source-hardcoded-records 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-hardcoded-records build
  ```

  An image will be available on your host with the tag `airbyte/source-hardcoded-records:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-hardcoded-records:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-hardcoded-records:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-hardcoded-records:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-hardcoded-records: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-hardcoded-records 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-hardcoded-records 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/hardcoded-records.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: 7d32c49a21b524e07e7d48ba3648405f15ed1d77c951ae673daa4a8e88abf662
name: python-airbyte-source-hubspot-help
arch: noarch
version: 4.4.3
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-hubspot
url: https://airbyte.com
rpm_license: ELv2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-hubspot-4.4.3-1.src.rpm
location_href: Packages/python-airbyte-source-hubspot-help-4.4.3-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Hubspot source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/hubspot).





  - 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/hubspot)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_hubspot/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-hubspot spec
  poetry run source-hubspot check --config secrets/config.json
  poetry run source-hubspot discover --config secrets/config.json
  poetry run source-hubspot read --config secrets/config.json --catalog integration_tests/basic_read_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-hubspot build
  ```

  An image will be available on your host with the tag `airbyte/source-hubspot:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-hubspot:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-hubspot:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-hubspot:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-hubspot: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-hubspot 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-hubspot 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/hubspot.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: d7d9354b1eda5d4fb5e127f201c70cd9fb38351dde603486934adfefebba40ef
name: python-airbyte-source-instatus-help
arch: noarch
version: 0.1.25
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-instatus
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-instatus-0.1.25-1.src.rpm
location_href: Packages/python-airbyte-source-instatus-help-0.1.25-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Instatus source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/instatus).




  * 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/instatus)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_instatus/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-instatus spec
  poetry run source-instatus check --config secrets/config.json
  poetry run source-instatus discover --config secrets/config.json
  poetry run source-instatus 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-instatus build
  ```

  An image will be available on your host with the tag `airbyte/source-instatus:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-instatus:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-instatus:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-instatus:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-instatus: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-instatus 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-instatus 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/instatus.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: d9a2538bfcf1cfeee8b5681ee8718365fe0d982c4456c15e82ee064b193469a9
name: python-airbyte-source-iterable-help
arch: noarch
version: 0.6.20
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-iterable
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-iterable-0.6.20-1.src.rpm
location_href: Packages/python-airbyte-source-iterable-help-0.6.20-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Iterable source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/iterable).





  - 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/iterable)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_iterable/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-iterable spec
  poetry run source-iterable check --config secrets/config.json
  poetry run source-iterable discover --config secrets/config.json
  poetry run source-iterable 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-iterable build
  ```

  An image will be available on your host with the tag `airbyte/source-iterable:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-iterable:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-iterable:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-iterable:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-iterable: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-iterable 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-iterable 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/iterable.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: 336c1d9faf1666a7ae02b8d52ee247fd412126124d187ad397e636b439527c0f
name: python-airbyte-source-jina-ai-reader-help
arch: noarch
version: 0.1.23
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-jina-ai-reader
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-jina-ai-reader-0.1.23-1.src.rpm
location_href: Packages/python-airbyte-source-jina-ai-reader-help-0.1.23-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Jina AI Reader configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/jina-ai-reader).





  * 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/jina-ai-reader)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `spec` inside `source_jina_ai_reader/mainfest.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 `integration_tests/sample_config.json` for a sample config file.




  ```
  poetry run source-jina-ai-reader spec
  poetry run source-jina-ai-reader check --config secrets/config.json
  poetry run source-jina-ai-reader discover --config secrets/config.json
  poetry run source-jina-ai-reader 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-jina-ai-reader build
  ```

  An image will be available on your host with the tag `airbyte/source-jina-ai-reader:dev`.




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-jina-ai-reader:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-jina-ai-reader:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-jina-ai-reader:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-jina-ai-reader: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-jina-ai-reader 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-jina-ai-reader 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/jina-ai-reader.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: 01b7cf8f71158bceeac050f9b18abd82340de4c47ac1d900d9846a9d48ddaaef
name: python-airbyte-source-jira-help
arch: noarch
version: 3.4.4
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-jira
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-jira-3.4.4-1.src.rpm
location_href: Packages/python-airbyte-source-jira-help-3.4.4-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Jira source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/jira).





  - 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/jira)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_jira/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-jira spec
  poetry run source-jira check --config secrets/config.json
  poetry run source-jira discover --config secrets/config.json
  poetry run source-jira 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-jira build
  ```

  An image will be available on your host with the tag `airbyte/source-jira:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-jira:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-jira:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-jira:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-jira: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-jira 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-jira 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/jira.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: bcb47299905c63e4c8ea77fea522a5fecf4aa9491c4494ef31f0882e52d3b6b6
name: python-airbyte-source-klaviyo-help
arch: noarch
version: 2.11.4
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-klaviyo
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-klaviyo-2.11.4-1.src.rpm
location_href: Packages/python-airbyte-source-klaviyo-help-2.11.4-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Klaviyo source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/klaviyo).





  - 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/klaviyo)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_klaviyo/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-klaviyo spec
  poetry run source-klaviyo check --config secrets/config.json
  poetry run source-klaviyo discover --config secrets/config.json
  poetry run source-klaviyo 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-klaviyo build
  ```

  An image will be available on your host with the tag `airbyte/source-klaviyo:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-klaviyo:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-klaviyo:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-klaviyo:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-klaviyo: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-klaviyo 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-klaviyo 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/klaviyo.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: 58bac175599e3ca6bdca81cdeafba66dbc38c48b2b402ae2403dd02d6a57dc34
name: python-airbyte-source-kyriba-help
arch: noarch
version: 0.1.27
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-kyriba
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-kyriba-0.1.27-1.src.rpm
location_href: Packages/python-airbyte-source-kyriba-help-0.1.27-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Kyriba source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/kyriba).





  - 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/kyriba)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_kyriba/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-kyriba spec
  poetry run source-kyriba check --config secrets/config.json
  poetry run source-kyriba discover --config secrets/config.json
  poetry run source-kyriba 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-kyriba build
  ```

  An image will be available on your host with the tag `airbyte/source-kyriba:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-kyriba:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-kyriba:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-kyriba:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-kyriba: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-kyriba 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-kyriba 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/kyriba.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: 3f060ac02d01c8faad8e9a46292a14e6cea86b0dd21b73762319df6a8f0a971c
name: python-airbyte-source-kyve-help
arch: noarch
version: 0.2.23
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-kyve
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-kyve-0.2.23-1.src.rpm
location_href: Packages/python-airbyte-source-kyve-help-0.2.23-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Kyve source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/kyve).




  * 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/kyve)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_kyve/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-kyve spec
  poetry run source-kyve check --config secrets/config.json
  poetry run source-kyve discover --config secrets/config.json
  poetry run source-kyve 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-kyve build
  ```

  An image will be available on your host with the tag `airbyte/source-kyve:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-kyve:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-kyve:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-kyve:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-kyve: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-kyve 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-kyve 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/kyve.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: 535bba4132c383e10af83620b9fb1eaf6aea561f3579e38630f6870d87660b62
name: python-airbyte-source-linkedin-ads-help
arch: noarch
version: 5.0.0
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-linkedin-ads
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-linkedin-ads-5.0.0-1.src.rpm
location_href: Packages/python-airbyte-source-linkedin-ads-help-5.0.0-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Linkedin-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/linkedin-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/linkedin-ads)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_linkedin_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 `integration_tests/sample_config.json` for a sample config file.



  ```
  poetry run source-linkedin-ads spec
  poetry run source-linkedin-ads check --config secrets/config.json
  poetry run source-linkedin-ads discover --config secrets/config.json
  poetry run source-linkedin-ads 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-linkedin-ads build
  ```

  An image will be available on your host with the tag `airbyte/source-linkedin-ads:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-linkedin-ads:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-linkedin-ads:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-linkedin-ads:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-linkedin-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-linkedin-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-linkedin-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/linkedin-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: 84ed9df4ab0ff6b130c33e84f7a24fcde95146f07971c458b8c2ad7cd9bfdea0
name: python-airbyte-source-linnworks-help
arch: noarch
version: 0.1.35
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-linnworks
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-linnworks-0.1.35-1.src.rpm
location_href: Packages/python-airbyte-source-linnworks-help-0.1.35-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Linnworks source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.io/integrations/sources/linnworks).





  - 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/linnworks)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_linnworks/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 `integration_tests/sample_config.json` for a sample config file.



  ```bash
  poetry run source-linnworks spec
  poetry run source-linnworks check --config secrets/config.json
  poetry run source-linnworks discover --config secrets/config.json
  poetry run source-linnworks read --config secrets/config.json --catalog integration_tests/configured_catalog.json
  ```



  To run unit tests locally, from the connector directory run:

  ```bash
  poetry run pytest unit_tests
  ```





  The Airbyte way of building this connector is to use our `airbyte-ci` tool.
  You can follow install instructions [here](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md#L1).
  Then running the following command will build your connector:

  ```bash
  airbyte-ci connectors --name source-linnworks build
  ```

  Once the command is done, you will find your connector image in your local docker registry: `airbyte/source-linnworks:dev`.



  When contributing on our connector you might need to customize the build process to add a system dependency or set an env var.
  You can customize our build process by adding a `build_customization.py` module to your connector.
  This module should contain a `pre_connector_install` and `post_connector_install` async function that will mutate the base image and the connector container respectively.
  It will be imported at runtime by our build process and the functions will be called if they exist.

  Here is an example of a `build_customization.py` module:

  ```python
  from __future__ import annotations

  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      
      
      from dagger import Container


  async def pre_connector_install(base_image_container: Container) -> Container:
      return await base_image_container.with_env_variable("MY_PRE_BUILD_ENV_VAR", "my_pre_build_env_var_value")

  async def post_connector_install(connector_container: Container) -> Container:
      return await connector_container.with_env_variable("MY_POST_BUILD_ENV_VAR", "my_post_build_env_var_value")
  ```



  This connector is built using our dynamic built process in `airbyte-ci`.
  The base image used to build it is defined within the metadata.yaml file under the `connectorBuildOptions`.
  The build logic is defined using [Dagger](https://dagger.io/) [here](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/pipelines/builds/python_connectors.py).
  It does not rely on a Dockerfile.

  If you would like to patch our connector and build your own a simple approach would be to:

  1. Create your own Dockerfile based on the latest version of the connector image.

  ```Dockerfile
  FROM airbyte/source-linnworks:latest

  COPY . ./airbyte/integration_code
  RUN pip install ./airbyte/integration_code




  ```

  Please use this as an example. This is not optimized.

  2. Build your image:

  ```bash
  docker build -t airbyte/source-linnworks:dev .

  docker run airbyte/source-linnworks:dev spec
  ```



  Then run any of the connector commands as follows:

  ```bash
  docker run --rm airbyte/source-linnworks:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-linnworks:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-linnworks:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-linnworks: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-linnworks test
  ```



  Customize `acceptance-test-config.yml` file to configure 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-linnworks test`
  2. Bump the connector version in `metadata.yaml`: increment the `dockerImageTag` value. Please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors).
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make the connector documentation and its changelog is up to date (`docs/integrations/sources/linnworks.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.


pkgId: 0c10215d9565dc31849347ac385c002bcdfb04456b9595b54809411a3b14def4
name: python-airbyte-source-looker-help
arch: noarch
version: 1.0.16
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-looker
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-looker-1.0.16-1.src.rpm
location_href: Packages/python-airbyte-source-looker-help-1.0.16-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Looker configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/looker).





  * 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/looker)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `src/source_looker/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-looker spec
  poetry run source-looker check --config secrets/config.json
  poetry run source-looker discover --config secrets/config.json
  poetry run source-looker read --config secrets/config.json --catalog sample_files/configured_catalog.json
  poetry run source-looker spec
  poetry run source-looker check --config secrets/config.json
  poetry run source-looker discover --config secrets/config.json
  poetry run source-looker read --config secrets/config.json --catalog sample_files/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-looker build
  ```

  An image will be available on your host with the tag `airbyte/source-looker:dev`.
  An image will be available on your host with the tag `airbyte/source-looker:dev`.




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-looker:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-looker:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-looker:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-looker: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-looker 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-looker 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/looker.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: 77cb5f65eea3c94123b32aed89208744636348002972134836af03576394c248
name: python-airbyte-source-mailchimp-help
arch: noarch
version: 2.0.21
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-mailchimp
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-mailchimp-2.0.21-1.src.rpm
location_href: Packages/python-airbyte-source-mailchimp-help-2.0.21-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Mailchimp source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/mailchimp).





  - 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/mailchimp)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_mailchimp/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-mailchimp spec
  poetry run source-mailchimp check --config secrets/config.json
  poetry run source-mailchimp discover --config secrets/config.json
  poetry run source-mailchimp 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-mailchimp build
  ```

  An image will be available on your host with the tag `airbyte/source-mailchimp:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-mailchimp:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-mailchimp:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-mailchimp:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-mailchimp: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-mailchimp 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-mailchimp 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/mailchimp.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: 1706b985e3d93f9a2115bbc8160fcf40db03287177e2955839b5e3aa834ba0fc
name: python-airbyte-source-microsoft-onedrive-help
arch: noarch
version: 0.2.25
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-microsoft-onedrive
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-microsoft-onedrive-0.2.25-1.src.rpm
location_href: Packages/python-airbyte-source-microsoft-onedrive-help-0.2.25-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Microsoft OneDrive source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/microsoft-onedrive).





  - 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/microsoft-onedrive)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_microsoft_onedrive/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-microsoft-onedrive spec
  poetry run source-microsoft-onedrive check --config secrets/config.json
  poetry run source-microsoft-onedrive discover --config secrets/config.json
  poetry run source-microsoft-onedrive 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-microsoft-onedrive build
  ```

  An image will be available on your host with the tag `airbyte/source-microsoft-onedrive:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-microsoft-onedrive:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-microsoft-onedrive:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-microsoft-onedrive:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-microsoft-onedrive: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-microsoft-onedrive 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-microsoft-onedrive 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/microsoft-onedrive.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: 80b152c51514e55922ce16179103c5eb18e7c90a2b102885c3e80f1899db99f9
name: python-airbyte-source-mixpanel-help
arch: noarch
version: 3.4.11
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-mixpanel
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-mixpanel-3.4.11-1.src.rpm
location_href: Packages/python-airbyte-source-mixpanel-help-3.4.11-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Mixpanel source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/mixpanel).





  - 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/mixpanel)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_mixpanel/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-mixpanel spec
  poetry run source-mixpanel check --config secrets/config.json
  poetry run source-mixpanel discover --config secrets/config.json
  poetry run source-mixpanel 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-mixpanel build
  ```

  An image will be available on your host with the tag `airbyte/source-mixpanel:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-mixpanel:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-mixpanel:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-mixpanel:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-mixpanel: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-mixpanel 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-mixpanel 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/mixpanel.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: a20d8c2358b9eef74d727ce13792820cc1c576bd9a2f6fc30210a01df5efba0f
name: python-airbyte-source-monday-help
arch: noarch
version: 2.1.6
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-monday
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-monday-2.1.6-1.src.rpm
location_href: Packages/python-airbyte-source-monday-help-2.1.6-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Monday source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/monday).





  - 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/monday)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_monday/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-monday spec
  poetry run source-monday check --config secrets/config.json
  poetry run source-monday discover --config secrets/config.json
  poetry run source-monday 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-monday build
  ```

  An image will be available on your host with the tag `airbyte/source-monday:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-monday:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-monday:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-monday:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-monday: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-monday 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-monday 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/monday.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: dac1ac74e33890b00b35d17ccc08f458017e4e146be5ad99da6c8cf2e5991cb2
name: python-airbyte-source-okta-help
arch: noarch
version: 0.3.13
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-okta
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-okta-0.3.13-1.src.rpm
location_href: Packages/python-airbyte-source-okta-help-0.3.13-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Okta configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/okta).





  * 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/okta)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `src/source_okta/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/config.json` for a sample config file.




  ```
  poetry run source-okta spec
  poetry run source-okta check --config secrets/config.json
  poetry run source-okta discover --config secrets/config.json
  poetry run source-okta 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-okta build
  ```

  An image will be available on your host with the tag `airbyte/source-okta:dev`.




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-okta:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-okta:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-okta:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-okta: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-okta 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-okta 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/okta.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: 4804736d667b0c4fd7400ef737bd63756c5595a9c46484d27654e806528c2d1d
name: python-airbyte-source-outbrain-amplify-help
arch: noarch
version: 0.1.23
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-outbrain-amplify
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-outbrain-amplify-0.1.23-1.src.rpm
location_href: Packages/python-airbyte-source-outbrain-amplify-help-0.1.23-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Outbrain Amplify source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/outbrain-amplify).





  **To iterate on this connector, make sure to complete this prerequisites section.**





  From this connector directory, create a virtual environment:

  ```
  python -m venv .venv
  ```

  This will generate a virtualenv for this module in `.venv/`. Make sure this venv is active in your
  development environment of choice. To activate it from the terminal, run:

  ```
  source .venv/bin/activate
  pip install -r requirements.txt
  pip install '.[tests]'
  ```

  If you are in an IDE, follow your IDE's instructions to activate the virtualenv.

  Note that while we are installing dependencies from `requirements.txt`, you should only edit `setup.py` for your dependencies. `requirements.txt` is
  used for editable installs (`pip install -e`) to pull in Python dependencies from the monorepo and will call `setup.py`.
  If this is mumbo jumbo to you, don't worry about it, just put your deps in `setup.py` but install using `pip install -r requirements.txt` and everything
  should work as you expect.



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/outbrain-amplify)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_outbrain_amplify/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 `integration_tests/sample_config.json` for a sample config file.

  **If you are an Airbyte core member**, copy the credentials in Lastpass under the secret name `source outbrain-amplify test creds`
  and place them into `secrets/config.json`.



  ```
  python main.py spec
  python main.py check --config secrets/config.json
  python main.py discover --config secrets/config.json
  python main.py read --config secrets/config.json --catalog integration_tests/configured_catalog.json
  ```






  The Airbyte way of building this connector is to use our `airbyte-ci` tool.
  You can follow install instructions [here](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md#L1).
  Then running the following command will build your connector:

  ```bash
  airbyte-ci connectors --name source-outbrain-amplify build
  ```
  Once the command is done, you will find your connector image in your local docker registry: `airbyte/source-outbrain-amplify:dev`.


  When contributing on our connector you might need to customize the build process to add a system dependency or set an env var.
  You can customize our build process by adding a `build_customization.py` module to your connector.
  This module should contain a `pre_connector_install` and `post_connector_install` async function that will mutate the base image and the connector container respectively.
  It will be imported at runtime by our build process and the functions will be called if they exist.

  Here is an example of a `build_customization.py` module:
  ```python
  from __future__ import annotations

  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      
      
      from dagger import Container


  async def pre_connector_install(base_image_container: Container) -> Container:
      return await base_image_container.with_env_variable("MY_PRE_BUILD_ENV_VAR", "my_pre_build_env_var_value")

  async def post_connector_install(connector_container: Container) -> Container:
      return await connector_container.with_env_variable("MY_POST_BUILD_ENV_VAR", "my_post_build_env_var_value")
  ```


  This connector is built using our dynamic built process in `airbyte-ci`.
  The base image used to build it is defined within the metadata.yaml file under the `connectorBuildOptions`.
  The build logic is defined using [Dagger](https://dagger.io/) [here](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/pipelines/builds/python_connectors.py).
  It does not rely on a Dockerfile.

  If you would like to patch our connector and build your own a simple approach would be to:

  1. Create your own Dockerfile based on the latest version of the connector image.
  ```Dockerfile
  FROM airbyte/source-outbrain-amplify:latest

  COPY . ./airbyte/integration_code
  RUN pip install ./airbyte/integration_code




  ```
  Please use this as an example. This is not optimized.

  2. Build your image:
  ```bash
  docker build -t airbyte/source-outbrain-amplify:dev .

  docker run airbyte/source-outbrain-amplify:dev spec
  ```


  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-outbrain-amplify:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-outbrain-amplify:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-outbrain-amplify:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-outbrain-amplify: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-outbrain-amplify test
  ```



  Customize `acceptance-test-config.yml` file to configure 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 go in `setup.py`, NOT `requirements.txt`. The requirements file is only used to connect internal Airbyte dependencies in the monorepo for local development.
  We split dependencies between two groups, dependencies that are:

  - required for your connector to work need to go to `MAIN_REQUIREMENTS` list.
  - required for the testing need to go to `TEST_REQUIREMENTS` list



  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-outbrain-amplify test`
  2. Bump the connector version in `metadata.yaml`: increment the `dockerImageTag` value. Please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors).
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make the connector documentation and its changelog is up to date (`docs/integrations/sources/outbrain-amplify.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.


pkgId: c4b29a08c143e6028bcfc1ebd53678b740419ae070eac4ce0cf3f83cd9f942f0
name: python-airbyte-source-outreach-help
arch: noarch
version: 1.0.24
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-outreach
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-outreach-1.0.24-1.src.rpm
location_href: Packages/python-airbyte-source-outreach-help-1.0.24-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Outreach configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/outreach).





  * 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/outreach)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `spec` inside `manifest.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 `integration_tests/sample_config.json` for a sample config file.





  ```
  poetry run source-outreach spec
  poetry run source-outreach check --config secrets/config.json
  poetry run source-outreach discover --config secrets/config.json
  poetry run source-outreach 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-outreach build
  ```

  An image will be available on your host with the tag `airbyte/source-outreach:dev`.





  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-outreach:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-outreach:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-outreach:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-outreach: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-outreach 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.

  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-outreach 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/outreach.md`).
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/outreach.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: ff33e96b9522c0b4eea596cb0dee947e46717f6eaa27fea9940f71a58ab88988
name: python-airbyte-source-partnerstack-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-partnerstack
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-partnerstack-0.2.2-1.src.rpm
location_href: Packages/python-airbyte-source-partnerstack-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Partnerstack source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/partnerstack).




  * 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/partnerstack)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_partnerstack/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-partnerstack spec
  poetry run source-partnerstack check --config secrets/config.json
  poetry run source-partnerstack discover --config secrets/config.json
  poetry run source-partnerstack 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-partnerstack build
  ```

  An image will be available on your host with the tag `airbyte/source-partnerstack:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-partnerstack:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-partnerstack:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-partnerstack:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-partnerstack: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-partnerstack 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-partnerstack 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/partnerstack.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: 9422668aba26a5119d80396bce938a72170aac53cd827d47ee594e3ef554f20f
name: python-airbyte-source-pinterest-help
arch: noarch
version: 2.0.23
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-pinterest
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-pinterest-2.0.23-1.src.rpm
location_href: Packages/python-airbyte-source-pinterest-help-2.0.23-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Pinterest source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/pinterest).





  - 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/pinterest)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_pinterest/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-pinterest spec
  poetry run source-pinterest check --config secrets/config.json
  poetry run source-pinterest discover --config secrets/config.json
  poetry run source-pinterest 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-pinterest build
  ```

  An image will be available on your host with the tag `airbyte/source-pinterest:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-pinterest:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-pinterest:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-pinterest:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-pinterest: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-pinterest 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-pinterest 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/pinterest.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: 9f50681ab0a7bc223e3e95d3c0d984526174126e3790b213ace9a273b59d669b
name: python-airbyte-source-pipedrive-help
arch: noarch
version: 2.2.28
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-pipedrive
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-pipedrive-2.2.28-1.src.rpm
location_href: Packages/python-airbyte-source-pipedrive-help-2.2.28-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Pipedrive source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/pipedrive).




  * 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/pipedrive)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_pipedrive/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-pipedrive spec
  poetry run source-pipedrive check --config secrets/config.json
  poetry run source-pipedrive discover --config secrets/config.json
  poetry run source-pipedrive 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-pipedrive build
  ```

  An image will be available on your host with the tag `airbyte/source-pipedrive:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-pipedrive:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-pipedrive:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-pipedrive:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-pipedrive: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-pipedrive 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-pipedrive 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/pipedrive.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: 526833967fc365153526ab12002dda3c1aa03a941c811b4a60e8aae74e8d71bb
name: python-airbyte-source-posthog-help
arch: noarch
version: 1.1.19
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-posthog
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-posthog-1.1.19-1.src.rpm
location_href: Packages/python-airbyte-source-posthog-help-1.1.19-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the PostHog source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.io/integrations/sources/posthog).





  * 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.io/integrations/sources/posthog)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_posthog/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 `sample_files/sample_config.json` for a sample config file.

  **If you are an Airbyte core member**, copy the credentials in Lastpass under the secret name `source posthog test creds`
  and place them into `secrets/config.json`.



  ```
  poetry run source-posthog spec
  poetry run source-posthog check --config secrets/config.json
  poetry run source-posthog discover --config secrets/config.json
  poetry run source-posthog read --config secrets/config.json --catalog sample_files/configured_catalog.json
  ```



  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-posthog build
  ```

  An image will be available on your host with the tag `airbyte/source-posthog:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-posthog:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-posthog:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-posthog:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/sample_files:/sample_files airbyte/source-posthog:dev read --config /secrets/config.json --catalog /sample_files/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-posthog test
  ```



  Customize `acceptance-test-config.yml` file to configure 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 go in `setup.py`, NOT `requirements.txt`. The requirements file is only used to connect internal Airbyte dependencies in the monorepo for local development.
  We split dependencies between two groups, dependencies that are:

  - required for your connector to work need to go to `MAIN_REQUIREMENTS` list.
  - required for the testing need to go to `TEST_REQUIREMENTS` list



  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-posthog test`
  2. Bump the connector version in `metadata.yaml`: increment the `dockerImageTag` value. Please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors).
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make the connector documentation and its changelog is up to date (`docs/integrations/sources/posthog.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.


pkgId: 12c41a8acf310a9e342329168c88ab6c358b7aea2bc6b80a5b1100989e717a72
name: python-airbyte-source-public-apis-help
arch: noarch
version: 0.2.24
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-public-apis
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-public-apis-0.2.24-1.src.rpm
location_href: Packages/python-airbyte-source-public-apis-help-0.2.24-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Public-Apis source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/public-apis).




  * 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/public-apis)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_public_apis/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-public-apis spec
  poetry run source-public-apis check --config secrets/config.json
  poetry run source-public-apis discover --config secrets/config.json
  poetry run source-public-apis 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-public-apis build
  ```

  An image will be available on your host with the tag `airbyte/source-public-apis:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-public-apis:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-public-apis:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-public-apis:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-public-apis: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-public-apis 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-public-apis 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/public-apis.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: cc5e356c4d4bac858df1ec31caa5d128001cb5c444bf3583afe9170f3ba8b366
name: python-airbyte-source-railz-help
arch: noarch
version: 0.1.19
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-railz
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-railz-0.1.19-1.src.rpm
location_href: Packages/python-airbyte-source-railz-help-0.1.19-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Railz source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/railz).




  * 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/railz)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_railz/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-railz spec
  poetry run source-railz check --config secrets/config.json
  poetry run source-railz discover --config secrets/config.json
  poetry run source-railz 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-railz build
  ```

  An image will be available on your host with the tag `airbyte/source-railz:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-railz:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-railz:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-railz:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-railz: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-railz 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-railz 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/railz.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: a9e7d8a4baebb17e94d1ed4076970c9d0b64008f7923f4b81bad5ec274640e37
name: python-airbyte-source-recharge-help
arch: noarch
version: 2.5.1
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-recharge
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-recharge-2.5.1-1.src.rpm
location_href: Packages/python-airbyte-source-recharge-help-2.5.1-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Recharge source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/recharge).





  - 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/recharge)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_recharge/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-recharge spec
  poetry run source-recharge check --config secrets/config.json
  poetry run source-recharge discover --config secrets/config.json
  poetry run source-recharge 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-recharge build
  ```

  An image will be available on your host with the tag `airbyte/source-recharge:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-recharge:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-recharge:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-recharge:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-recharge: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-recharge 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-recharge 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/recharge.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: f198a0f69ed1282de6b6e94783a488db5b6f9c302aaf4e17e70f0e351637ec00
name: python-airbyte-source-rki-covid-help
arch: noarch
version: 0.1.27
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-rki-covid
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-rki-covid-0.1.27-1.src.rpm
location_href: Packages/python-airbyte-source-rki-covid-help-0.1.27-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Rki-Covid source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/rki-covid).




  * 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/rki-covid)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_rki_covid/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-rki-covid spec
  poetry run source-rki-covid check --config secrets/config.json
  poetry run source-rki-covid discover --config secrets/config.json
  poetry run source-rki-covid 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-rki-covid build
  ```

  An image will be available on your host with the tag `airbyte/source-rki-covid:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-rki-covid:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-rki-covid:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-rki-covid:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-rki-covid: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-rki-covid 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-rki-covid 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/rki-covid.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: 8ea41bd3e147169e0d2e885bec657cf8360d431a91b89dc1b0584aefa949bd07
name: python-airbyte-source-rss-help
arch: noarch
version: 1.0.26
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-rss
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-rss-1.0.26-1.src.rpm
location_href: Packages/python-airbyte-source-rss-help-1.0.26-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Rss configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/rss).





  - 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/rss)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `src/source_rss/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 `integration_tests/sample_config.json` for a sample config file.



  ```
  poetry run source-rss spec
  poetry run source-rss check --config secrets/config.json
  poetry run source-rss discover --config secrets/config.json
  poetry run source-rss 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-rss build
  ```

  An image will be available on your host with the tag `airbyte/source-rss:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-rss:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-rss:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-rss:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-rss: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-rss 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-rss 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/rss.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: 31826a4c4d1b6cf2978104ce9697639aa50559fad17085009217471d2f3c1cdb
name: python-airbyte-source-s3-help
arch: noarch
version: 4.10.2
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-s3
url: https://airbyte.com
rpm_license: ELv2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-s3-4.10.2-1.src.rpm
location_href: Packages/python-airbyte-source-s3-help-4.10.2-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the S3 source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/s3).





  - 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/s3)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_s3/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-s3 spec
  poetry run source-s3 check --config secrets/config.json
  poetry run source-s3 discover --config secrets/config.json
  poetry run source-s3 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-s3 build
  ```

  An image will be available on your host with the tag `airbyte/source-s3:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-s3:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-s3:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-s3:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-s3: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-s3 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-s3 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/s3.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: c5a86244b2b1753c2d304e2b871bf34ac2f4f0fcd87b38b9d0174e27160d8a32
name: python-airbyte-source-sftp-bulk-help
arch: noarch
version: 1.5.0
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-sftp-bulk
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-sftp-bulk-1.5.0-1.src.rpm
location_href: Packages/python-airbyte-source-sftp-bulk-help-1.5.0-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Sftp-Bulk source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/sftp-bulk).





  - 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/sftp-bulk)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_sftp_bulk/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-sftp-bulk spec
  poetry run source-sftp-bulk check --config secrets/config.json
  poetry run source-sftp-bulk discover --config secrets/config.json
  poetry run source-sftp-bulk 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-sftp-bulk build
  ```

  An image will be available on your host with the tag `airbyte/source-sftp-bulk:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-sftp-bulk:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-sftp-bulk:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-sftp-bulk:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-sftp-bulk: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-sftp-bulk 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-sftp-bulk 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/sftp-bulk.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: cf6bf294ecb3547cb09ea342b57959dab37e59d9cf12cd27f0af95868ea43865
name: python-airbyte-source-smartsheets-help
arch: noarch
version: 1.1.27
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-smartsheets
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-smartsheets-1.1.27-1.src.rpm
location_href: Packages/python-airbyte-source-smartsheets-help-1.1.27-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Smartsheets source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/smartsheets).




  * 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/smartsheets)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_smartsheets/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-smartsheets spec
  poetry run source-smartsheets check --config secrets/config.json
  poetry run source-smartsheets discover --config secrets/config.json
  poetry run source-smartsheets 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-smartsheets build
  ```

  An image will be available on your host with the tag `airbyte/source-smartsheets:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-smartsheets:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-smartsheets:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-smartsheets:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-smartsheets: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-smartsheets 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-smartsheets 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/smartsheets.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: 8fde8767d2a39a4ff5c4b99eec4962bf65623a2d0dd5186ed3ee7599a6a1234a
name: python-airbyte-source-stripe-help
arch: noarch
version: 5.8.1
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-stripe
url: https://airbyte.com
rpm_license: Elv2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-stripe-5.8.1-1.src.rpm
location_href: Packages/python-airbyte-source-stripe-help-5.8.1-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Stripe source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/stripe).





  - 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/stripe)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_stripe/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-stripe spec
  poetry run source-stripe check --config secrets/config.json
  poetry run source-stripe discover --config secrets/config.json
  poetry run source-stripe 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-stripe build
  ```

  An image will be available on your host with the tag `airbyte/source-stripe:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-stripe:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-stripe:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-stripe:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-stripe: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-stripe 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-stripe 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/stripe.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: c9ef368acc24cdb1af032951d297a5d07b61d96bdfc1c96bf425aee9618296f7
name: python-airbyte-source-surveycto-help
arch: noarch
version: 0.1.29
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-surveycto
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-surveycto-0.1.29-1.src.rpm
location_href: Packages/python-airbyte-source-surveycto-help-0.1.29-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Surveycto source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/surveycto).




  * 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/surveycto)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_surveycto/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-surveycto spec
  poetry run source-surveycto check --config secrets/config.json
  poetry run source-surveycto discover --config secrets/config.json
  poetry run source-surveycto 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-surveycto build
  ```

  An image will be available on your host with the tag `airbyte/source-surveycto:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-surveycto:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-surveycto:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-surveycto:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-surveycto: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-surveycto 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-surveycto 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/surveycto.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: effc8875c9030ec105421bd5fb6d07a1f3e325b2445d90d5fe5015dedeedc23a
name: python-airbyte-source-tplcentral-help
arch: noarch
version: 0.1.28
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-tplcentral
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-tplcentral-0.1.28-1.src.rpm
location_href: Packages/python-airbyte-source-tplcentral-help-0.1.28-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Tplcentral source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/tplcentral).




  * 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/tplcentral)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_tplcentral/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-tplcentral spec
  poetry run source-tplcentral check --config secrets/config.json
  poetry run source-tplcentral discover --config secrets/config.json
  poetry run source-tplcentral 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-tplcentral build
  ```

  An image will be available on your host with the tag `airbyte/source-tplcentral:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-tplcentral:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-tplcentral:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-tplcentral:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-tplcentral: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-tplcentral 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-tplcentral 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/tplcentral.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: 8054a67d8d3c56801c1589d924d6a638c22987ff6fe38939c643c06925a16497
name: python-airbyte-source-typeform-help
arch: noarch
version: 1.3.21
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-typeform
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-typeform-1.3.21-1.src.rpm
location_href: Packages/python-airbyte-source-typeform-help-1.3.21-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Typeform source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/typeform).





  - 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/typeform)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_typeform/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-typeform spec
  poetry run source-typeform check --config secrets/config.json
  poetry run source-typeform discover --config secrets/config.json
  poetry run source-typeform 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-typeform build
  ```

  An image will be available on your host with the tag `airbyte/source-typeform:dev`.



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-typeform:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-typeform:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-typeform:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-typeform: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-typeform 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-typeform 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/typeform.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: 2f1a1e39431bb32ff1f46fd3078b77d52f810f7868bf4fb3ec26d4d93ed604e8
name: python-airbyte-source-webflow-help
arch: noarch
version: 0.1.29
epoch: 0
release: 1
summary: Development documents and examples for airbyte-source-webflow
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airbyte-source-webflow-0.1.29-1.src.rpm
location_href: Packages/python-airbyte-source-webflow-help-0.1.29-1.noarch.rpm
checksum_type: sha256
description:
  This is the repository for the Webflow source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/webflow).




  * 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/webflow)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_webflow/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-webflow spec
  poetry run source-webflow check --config secrets/config.json
  poetry run source-webflow discover --config secrets/config.json
  poetry run source-webflow 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-webflow build
  ```

  An image will be available on your host with the tag `airbyte/source-webflow:dev`.



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-webflow:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-webflow:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-webflow:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-webflow: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-webflow 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-webflow 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/webflow.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.


