# packages

pkgId: d72c3ae14326ba8f117cc067f8fd1239a3fb27cc82e956633e93978a3f73fee4
name: python-airbyte-source-rss
arch: src
version: 1.0.23
epoch: 0
release: 1
summary: Source implementation for rss.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-rss-1.0.23-1.src.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: 446ecc5b634c3d9c330e32c1793fc45c5704d683391d980028f2d6ad98bd728e
name: python-airbyte-source-s3
arch: src
version: 4.10.1
epoch: 0
release: 1
summary: Source implementation for S3.
url: https://airbyte.com
rpm_license: ELv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-s3-4.10.1-1.src.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: c7e2014bd95273cca46bae94dc74650ad01f262cc56339ba40f05a7f9a129364
name: python-airbyte-source-salesforce
arch: src
version: 2.6.2
epoch: 0
release: 1
summary: Source implementation for Salesforce.
url: https://airbyte.com
rpm_license: ELv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-salesforce-2.6.2-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Salesforce source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/salesforce).





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

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



  Then run any of the connector commands as follows:

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




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

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


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




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

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



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




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

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



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





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

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



  Then run any of the connector commands as follows:

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





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

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




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




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

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



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





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

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




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-serpstat:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-serpstat:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-serpstat:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-serpstat: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-serpstat 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-serpstat 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/serpstat.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: 8e9a53f6c7db69c180174fb6aee5604a072308896fb5986918702913253c29e9
name: python-airbyte-source-sftp-bulk
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Source implementation for SFTP Bulk.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-sftp-bulk-1.5.0-1.src.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: 3c2fd033f58f94882590204a98ff78c3a1374cf9e28e8e1fbec27dbdcc0f05dc
name: python-airbyte-source-shopify
arch: src
version: 2.5.12
epoch: 0
release: 1
summary: Source CDK implementation for Shopify.
url: https://airbyte.com
rpm_license: ELv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-shopify-2.5.12-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Shopify source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/shopify).





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

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



  Then run any of the connector commands as follows:

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





  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/shortio)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_shortio/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 shortio test creds`
  and place them into `secrets/config.json`.





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

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

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

  **Via `docker build`:**

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



  Then run any of the connector commands as follows:

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




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

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



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





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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-smartengage:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-smartengage:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-smartengage:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-smartengage: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-smartengage 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-smartengage 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/smartengage.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: 563ff852afcf18dea13507523ae1670cb29409ba23ea983323d4c6eccc9ae9fc
name: python-airbyte-source-smartsheets
arch: src
version: 1.1.24
epoch: 0
release: 1
summary: Source implementation for Smartsheets.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-smartsheets-1.1.24-1.src.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: 74192a70af3d27811f09bcc75cfa1d4ce8f67514bd989573de6af875d88dbb29
name: python-airbyte-source-snapchat-marketing
arch: src
version: 1.2.12
epoch: 0
release: 1
summary: Source implementation for Snapchat Marketing.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-snapchat-marketing-1.2.12-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Snapchat-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/snapchat-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/snapchat-marketing)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_snapchat_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-snapchat-marketing spec
  poetry run source-snapchat-marketing check --config secrets/config.json
  poetry run source-snapchat-marketing discover --config secrets/config.json
  poetry run source-snapchat-marketing 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-snapchat-marketing build
  ```

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-snapchat-marketing:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-snapchat-marketing:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-snapchat-marketing:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-snapchat-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-snapchat-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-snapchat-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/snapchat-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: 6a14b341baea463a2c1b2259975c4ece0080ca0c59eb3c58a987d021022f95bc
name: python-airbyte-source-sonar-cloud
arch: src
version: 0.1.17
epoch: 0
release: 1
summary: Source implementation for Sonar Cloud.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-sonar-cloud-0.1.17-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Sonar-Cloud source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/sonar-cloud).





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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-sonar-cloud:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-sonar-cloud:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-sonar-cloud:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-sonar-cloud: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-sonar-cloud 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-sonar-cloud 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/sonar-cloud.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: c0f474d7dd260137a83465d04c10473065cc69ca8c7b0b082743bf03007daf3a
name: python-airbyte-source-spacex-api
arch: src
version: 0.1.13
epoch: 0
release: 1
summary: Source implementation for Spacex Api.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-spacex-api-0.1.13-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Spacex-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/spacex-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/spacex-api)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_spacex_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-spacex-api spec
  poetry run source-spacex-api check --config secrets/config.json
  poetry run source-spacex-api discover --config secrets/config.json
  poetry run source-spacex-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-spacex-api build
  ```

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


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





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

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



  Then run any of the connector commands as follows:

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





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

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




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-statuspage:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-statuspage:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-statuspage:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-statuspage: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-statuspage 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-statuspage 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/statuspage.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: 12d37edd3cdeff617227ccddbe83d0733f85e08d6438d3ea91c4997fcd859194
name: python-airbyte-source-stripe
arch: src
version: 5.6.2
epoch: 0
release: 1
summary: Source implementation for Stripe.
url: https://airbyte.com
rpm_license: Elv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-stripe-5.6.2-1.src.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: 868ac045bf293cf094a2e9e94f7a90b2071366d377ba65420a88b8ba6f9277e1
name: python-airbyte-source-survey-sparrow
arch: src
version: 0.2.14
epoch: 0
release: 1
summary: Source implementation for Survey Sparrow.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-survey-sparrow-0.2.14-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Survey-Sparrow source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/survey-sparrow).





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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-survey-sparrow:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-survey-sparrow:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-survey-sparrow:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-survey-sparrow: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-survey-sparrow 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-survey-sparrow 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/survey-sparrow.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: 818cff9bbc171914a34336e552904aca00cb20a046a7737965c1fe2e2d117ee1
name: python-airbyte-source-surveycto
arch: src
version: 0.1.26
epoch: 0
release: 1
summary: Source implementation for Surveycto.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-surveycto-0.1.26-1.src.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: 9430112896cbbbfb681d971948b2297a5c0362f9557cfc130da9642c9a839f89
name: python-airbyte-source-surveymonkey
arch: src
version: 0.3.28
epoch: 0
release: 1
summary: Source implementation for Surveymonkey.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-surveymonkey-0.3.28-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Surveymonkey source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/surveymonkey).





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

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



  Then run any of the connector commands as follows:

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





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




  ```
  poetry run source-tempo spec
  poetry run source-tempo check --config secrets/config.json
  poetry run source-tempo discover --config secrets/config.json
  poetry run source-tempo 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-tempo build
  airbyte-ci connectors --name=source-tempo build
  ```

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





  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-tempo:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-tempo:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-tempo:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-tempo:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  docker run --rm airbyte/source-tempo:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-tempo:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-tempo:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-tempo: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-tempo 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-tempo 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`
  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/tempo.md`).
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/tempo.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.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


pkgId: cadfac4c7119c515a43c7fb3cf3c8da6062569b47a94455c24dcfc171e11123e
name: python-airbyte-source-the-guardian-api
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Source implementation for the guardian api.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-the-guardian-api-0.1.9-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the The Guardian Api configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.io/integrations/sources/the-guardian-api).





  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.io/integrations/sources/the-guardian-api)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_the_guardian_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 `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 the-guardian-api 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-the-guardian-api build
  ```
  Once the command is done, you will find your connector image in your local docker registry: `airbyte/source-the-guardian-api: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-the-guardian-api: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-the-guardian-api:dev .

  docker run airbyte/source-the-guardian-api:dev spec
  ```


  Then run any of the connector commands as follows:

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


pkgId: f04d2d7f84b1f975ea0de90fc780a126890703dae2be1c0a57161ed397ad6b60
name: python-airbyte-source-tiktok-marketing
arch: src
version: 4.3.6
epoch: 0
release: 1
summary: Source implementation for Tiktok Marketing.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-tiktok-marketing-4.3.6-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Tiktok-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/tiktok-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/tiktok-marketing)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_tiktok_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-tiktok-marketing spec
  poetry run source-tiktok-marketing check --config secrets/config.json
  poetry run source-tiktok-marketing discover --config secrets/config.json
  poetry run source-tiktok-marketing 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-tiktok-marketing build
  ```

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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




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

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



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




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

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-toggl:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-toggl:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-toggl:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-toggl: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-toggl 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-toggl 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/toggl.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: 6d4fd1c39a9c26661eb60ddb0b4690ca3f075d44db0a267e7893e60953590d40
name: python-airbyte-source-tplcentral
arch: src
version: 0.1.25
epoch: 0
release: 1
summary: Source implementation for Tplcentral.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-tplcentral-0.1.25-1.src.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: b4391231c29256c21bd5c08d3083756bd26ce853082488aac79691701c935065
name: python-airbyte-source-trello
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Source implementation for Trello.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-trello-1.1.0-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Trello configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/trello).





  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/trello)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_trello/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 trello test creds`
  and place them into `secrets/config.json`.



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





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

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

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

  **Via `docker build`:**

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



  Then run any of the connector commands as follows:

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




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

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-trustpilot:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-trustpilot:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-trustpilot:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-trustpilot: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-trustpilot 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-trustpilot 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/trustpilot.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: 4778c446fb4da1dcf3e871d99dafc684728977de7b4ee3e67936f3636023d2a3
name: python-airbyte-source-tvmaze-schedule
arch: src
version: 0.1.13
epoch: 0
release: 1
summary: Source implementation for Tvmaze Schedule.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-tvmaze-schedule-0.1.13-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Tvmaze-Schedule source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/tvmaze-schedule).




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

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



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





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

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



  Then run any of the connector commands as follows:

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




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

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-twitter:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-twitter:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-twitter:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-twitter: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-twitter 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-twitter 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/twitter.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: 5f1ac794097fb05bf3b701debd2fe1289b4bc22024f0e9863f1504d07e6378ee
name: python-airbyte-source-tyntec-sms
arch: src
version: 0.1.13
epoch: 0
release: 1
summary: Source implementation for Tyntec Sms.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-tyntec-sms-0.1.13-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Tyntec-Sms source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/tyntec-sms).




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

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-tyntec-sms:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-tyntec-sms:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-tyntec-sms:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-tyntec-sms: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-tyntec-sms 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-tyntec-sms 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/tyntec-sms.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: 5b3d6d07e0c940c451319f395a8bc6455647141da65480096cd2d0410a60ca97
name: python-airbyte-source-typeform
arch: src
version: 1.3.17
epoch: 0
release: 1
summary: Source implementation for Typeform.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-typeform-1.3.17-1.src.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: 4de4043ec059b6694b2fed14d6210ea5e4fda946bfcfbb7b7558a8aeb0896b6b
name: python-airbyte-source-unleash
arch: src
version: 0.1.18
epoch: 0
release: 1
summary: Source implementation for Unleash.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-unleash-0.1.18-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Unleash source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/unleash).




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

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-unleash:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-unleash:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-unleash:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-unleash: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-unleash 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-unleash 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/unleash.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: 64be70bca83a315c8fe6c62fd652eaa5038ee5cd5b967644d7e928a4b15a1dda
name: python-airbyte-source-vantage
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: Source implementation for Vantage.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-vantage-0.1.14-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the 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/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/vantage)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_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-vantage spec
  poetry run source-vantage check --config secrets/config.json
  poetry run source-vantage discover --config secrets/config.json
  poetry run source-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-vantage build
  ```

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



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





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

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



  Then run any of the connector commands as follows:

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





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




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

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




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-vitally:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-vitally:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-vitally:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-vitally: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-vitally 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-vitally 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`
  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/vitally.md`).
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/vitally.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.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


pkgId: 9e9b3fdd6d0fc112ac91c58a91610f28e53781e6f0000e57b2b74b626690dafe
name: python-airbyte-source-waiteraid
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: Source implementation for Waiteraid.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-waiteraid-0.1.14-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Waiteraid source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/waiteraid).




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

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



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





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

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




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-weatherstack:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-weatherstack:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-weatherstack:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-weatherstack: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-weatherstack 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-weatherstack 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/weatherstack.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: 44c7d738f3bf3dd49f625f33fe15f71974f268dcdd80a30b31ae8868d36cf007
name: python-airbyte-source-webflow
arch: src
version: 0.1.27
epoch: 0
release: 1
summary: Source implementation for Webflow.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-webflow-0.1.27-1.src.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.


pkgId: 6ace05cc45690432dc0ad08664afa575164c50cfc1bfcb77ee269363cc5b1316
name: python-airbyte-source-whisky-hunter
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: Source implementation for Whisky Hunter.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-whisky-hunter-0.1.14-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Whisky-Hunter source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/whisky-hunter).




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

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-whisky-hunter:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-whisky-hunter:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-whisky-hunter:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-whisky-hunter: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-whisky-hunter 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-whisky-hunter 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/whisky-hunter.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: 829ff900de55b5eca785effb725616e2784aaf7970fcfab256ef650c48a3057b
name: python-airbyte-source-wikipedia-pageviews
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: Source implementation for wikipedia-pageviews.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-wikipedia-pageviews-0.1.10-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Wikipedia Pageviews configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/wikipedia-pageviews).





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

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




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




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

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



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





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




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

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




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-workable:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-workable:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-workable:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-workable: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-workable 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-workable 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`
  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/workable.md`).
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/workable.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.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


pkgId: b5764148d01c9cd33f17f49b543e79f2390c4603cf497080c4863913c4c012b8
name: python-airbyte-source-workramp
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: Source implementation for Workramp.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-workramp-0.1.10-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Workramp configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/workramp).




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

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



  Then run any of the connector commands as follows:

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





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

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




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




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

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-xkcd:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-xkcd:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-xkcd:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-xkcd: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-xkcd 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-xkcd 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/xkcd.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: 6c27a75cea3a5c11238993f80b511b5a8951ec4e860a9a4f2887d1b151f844a0
name: python-airbyte-source-yahoo-finance-price
arch: src
version: 0.2.23
epoch: 0
release: 1
summary: Source implementation for Yahoo Finance Price.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-yahoo-finance-price-0.2.23-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Yahoo-Finance-Price source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/yahoo-finance-price).





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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-yahoo-finance-price:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-yahoo-finance-price:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-yahoo-finance-price:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-yahoo-finance-price: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-yahoo-finance-price 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-yahoo-finance-price 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/yahoo-finance-price.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: 96fde47503908e20a9d3d89480b63afd9703a39695ae6dee4ce94fab3bb74a39
name: python-airbyte-source-yandex-metrica
arch: src
version: 1.0.23
epoch: 0
release: 1
summary: Source implementation for Yandex Metrica.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-yandex-metrica-1.0.23-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Yandex-Metrica source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/yandex-metrica).





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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-younium:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-younium:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-younium:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-younium: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-younium 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-younium 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/younium.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: 92e597c4f6e1dc8ea24dd878bef084063a2aa1a5e62777a7585f92d83635ad1e
name: python-airbyte-source-zapier-supported-storage
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: Source implementation for Zapier Supported Storage.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-zapier-supported-storage-0.1.14-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Zapier-Supported-Storage source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/zapier-supported-storage).





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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-zapier-supported-storage:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-zapier-supported-storage:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-zapier-supported-storage:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-zapier-supported-storage: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-zapier-supported-storage 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-zapier-supported-storage 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/zapier-supported-storage.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: c8bacd6fa34b3b8fabdc0d6e2faea9c75f08098f58ad65008ce5c50142eee0a6
name: python-airbyte-source-zendesk-sell
arch: src
version: 0.2.14
epoch: 0
release: 1
summary: Source implementation for Zendesk Sell.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-zendesk-sell-0.2.14-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Zendesk-Sell source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/zendesk-sell).




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

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



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





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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-zendesk-sunshine:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-zendesk-sunshine:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-zendesk-sunshine:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-zendesk-sunshine: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-zendesk-sunshine 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-zendesk-sunshine 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/zendesk-sunshine.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: d0827109518c2d6a795388f1e1fe8c80f6098b3a7e1e07e483cb1469c3ed218d
name: python-airbyte-source-zendesk-support
arch: src
version: 4.3.2
epoch: 0
release: 1
summary: Source implementation for Zendesk Support.
url: https://airbyte.com
rpm_license: ELv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-zendesk-support-4.3.2-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Zendesk-Support source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/zendesk-support).





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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-zendesk-support:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-zendesk-support:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-zendesk-support:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-zendesk-support: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-zendesk-support 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-zendesk-support 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/zendesk-support.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: 46ed7f34fb54459c91b6415270dd0959663da2e4aa2536dbecb0c8a281803304
name: python-airbyte-source-zendesk-talk
arch: src
version: 1.0.21
epoch: 0
release: 1
summary: Source implementation for Zendesk Talk.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-zendesk-talk-1.0.21-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Zendesk-Talk source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/zendesk-talk).





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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-zendesk-talk:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-zendesk-talk:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-zendesk-talk:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-zendesk-talk: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-zendesk-talk 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-zendesk-talk 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/zendesk-talk.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: 02d033e29cf106b5e84bf2234ca76022080c3bcad773fc5db0838316e0bd6f84
name: python-airbyte-source-zenefits
arch: src
version: 0.2.13
epoch: 0
release: 1
summary: Source implementation for Zenefits.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-zenefits-0.2.13-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Zenefits source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/zenefits).





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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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





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

  Once the command is done, you will find your connector image in your local docker registry: `airbyte/source-zoom: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-zoom: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-zoom:dev .

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-zoom:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-zoom:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-zoom:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-zoom: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-zoom 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-zoom 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/zoom.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: 4724d99703c48f52fbddb006f0d54811d9fb4b7c5e3ad4aecd4235934bbb3ad5
name: python-aircalc
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: aircalc: calculate a math expression by five fingers in air.
url: https://github.com/y-takefuji/air_calculator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aircalc-0.0.7-1.src.rpm
checksum_type: sha256
description:
  This is under review.

  aircalc has been downloaded by 20,387 downloads worldwide as of Feb.24, 2023.

  aircalc is a Python program based on two state-of-the-art libraries including hand gesture recognition library
  using mediapipe and optical character recognition library using tesseract.
  aircalc can be easilly installed by pip command (PyPi).
  This short program is made for education by showing how to use two state-of-the-art libraries.
  aircalc has an error correction function for correcting hand-drawn images in order to achieve perfect image recognition by tesseract.

  The paper on aircalc is under submission. If the paper is accepted, the source code will be disclosed with detailed explanations.

  The hand gesture recognition allows you to draw a math expression and it will be automatically calculated. The answer will be posted on the screen.

  Writing letters with a pen on paper is very different from drawing letters in the air.

  Drawing "-" minus operator and "+" operator in the air are extremely difficult so that these operators in the current system are replaced by "W" and "P" respectively.

  When drawing letters with fingers in the air, letters that are difficult
  to recognize or write in the air need to be replaced with letters
  that can be accurately recognized by artificial intelligence.
  For example, replace the number "1" with "L" in the air.



  $ pip install pytesseract

  For Windows users, you should also install the latest tesseract

  https://github.com/UB-Mannheim/tesseract/wiki

  And add tesseract.exe of Tesseract-OCR directory PATH in .profile or .bashrc.

  $ pip install mediapipe

  Finally install aircalc

  $ pip install aircalc

  $ pip install aircalc --force-reinstall --no-cache-dir --no-binary :all:



  aircalc is a program for drawing a math expression
  in the air for possible calculation.

  aircalc is based on two open source libraries including mediapipe and tesseract.

  There are six states of five fingers recognized by mediapipe library:
  0-finger, 1-finger, 2-finger, 3-finger, 4-finger, and 5-finger respectively.
  <pre>
  A pen of index finger tip is used for drawing an expression
  by fingers.

  0-finger can move the pen without drawing.
  1-finger can draw lines in the air.
  2-finger can move the pen without drawing.
  3-finger can delete the last touches of drawn letters for correction.
  4-finger can call tesseract for transforming the hand-writing
  images to the digital text for possible calculation.
  For several seconds, 4-finger can terminate the program
  for showing the answer of the hand-drawn expression.
  5-finger can move the pen without drawing.
  </pre>

  Continuous 4-finger state can terminate and exit this program.

  0-finger or 5-finger is equivalent to 2-finger.

  The saved picture is tranformed into digital text using the state-of-the-art
  optical character recognition.

  Writing letters with a pen on paper is very different from drawing letters in the air.

  Of the 0 to 9 digits, 1 is the least recognizable number.

  Drawing "L" in the air represents "1".

  "S" or "5" in the air represents "5".

  "P" in the air represents "+" plus operator.

  "W" or "-" represents "-" minus operator.

  "V" in the air represents "/" division operator.

  "M" in the air represents "*" multiplication operator.

  "&" in the air represents "\**" exponential operator.

  Drawing two letters "a" and "A" in the air represents the sqrt() function.
  Therefore, the string "a13A" or "aL3A" represents sqrt(13).

  $ aircalc

  https://youtu.be/med_jrFTMPA
  <pre>  sqrt(6)*2=?    </pre>
  <img src='https://github.com/y-takefuji/air_calculator/raw/main/a6AM2.png' width=320 height=240>

  <pre>         1-3=?                10+2=?  </pre>
  [![Lw3.gif](https://github.com/y-takefuji/air_calculator/raw/main/Lw3.gif)](https://github.com/y-takefuji/air_calculator)    [![10plus2.gif](https://github.com/y-takefuji/air_calculator/raw/main/10plus2.gif)](https://github.com/y-takefuji/air_calculator)

  <pre>        4-5-3=?            </pre>
  [![4-5-3.gif](https://github.com/y-takefuji/air_calculator/raw/main/4-5-3.gif) <img src='https://github.com/y-takefuji/air_calculator/raw/main/4-5-3.png' width=160 height=120> <img src='https://github.com/y-takefuji/air_calculator/raw/main/resize_4-5-3.png' width=120 height=90>

  <pre>        2-3/5=?   </pre>
  [![2-3div5.gif](https://github.com/y-takefuji/air_calculator/raw/main/2-3div5.gif)
  <img src='https://github.com/y-takefuji/air_calculator/raw/main/2-3div5.png' width=160 height=120> <img src='https://github.com/y-takefuji/air_calculator/raw/main/resize_2-3div5.png' width=120 height=90>


  <pre>        34*5=?     </pre>
  [![34M5.gif](https://github.com/y-takefuji/air_calculator/raw/main/34M5.gif)
  <img src='https://github.com/y-takefuji/air_calculator/raw/main/34M5.png' width=160 height=120>
  <img src='https://github.com/y-takefuji/air_calculator/raw/main/resize_34M5.png' width=120 height=90>

  <pre> 2**8=?</pre>
  [![2^8.gif](https://github.com/y-takefuji/air_calculator/raw/main/2^8.gif)


  <pre>      2&9V3 --> 2**9/3        </pre>
  [![2^9div3.gif](https://github.com/y-takefuji/air_calculator/raw/main/2^9div3.gif)
  <img src='https://github.com/y-takefuji/air_calculator/raw/main/2^9div3.png' width=160 height=120>
  <img src='https://github.com/y-takefuji/air_calculator/raw/main/resize_2^9div3.png' width=120 height=90>

  <pre>       aLLAV3=? -> sqrt(11)/3 </pre>
  [![aLLAV3.gif](https://github.com/y-takefuji/air_calculator/raw/main/aLLAV3.gif)
  <img src='https://github.com/y-takefuji/air_calculator/raw/main/aLLAV3.png' width=160 height=120>
  <img src='https://github.com/y-takefuji/air_calculator/raw/main/resize_aLLAV3.png' width=120 height=90>


pkgId: dc93c1d09e1257b9299a2330e01506e2b1ab890e1df10e863035e507727a852b
name: python-aircloudy
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: A library to pilot hitachi aircloud AC
url: https://github.com/ylemoigne/aircloudy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aircloudy-0.1.10-1.src.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [Installation](#installation)
  - [Usage](#usage)
  - [License](#license)
  - [Development](#development)

  ```console
  pip install aircloudy
  ```

  ```python
  from __future__ import annotations
  import asyncio
  from aircloudy import HitachiAirCloud, InteriorUnit, compute_interior_unit_diff_description
  def print_changes(dict: dict[int, tuple[InteriorUnit|None, InteriorUnit|None]]) -> None:
      for (id, change) in dict.items():
          print(f"Change on interior unit {id}: "+compute_interior_unit_diff_description(change[0], change[1]))
  async def main() -> None:
      async with HitachiAirCloud("your@email.com", "top_secret") as ac:
          ac.on_change = print_changes
          unit_bureau = next((iu for iu in ac.interior_units if iu.name == "Bureau"), None)
          if unit_bureau is None:
              raise Exception("No unit named `Bureau`")
          await ac.set(unit_bureau.id, "ON")
          await ac.set(unit_bureau.id, requested_temperature=21, fan_speed="LV3")
          await asyncio.sleep(30)
  asyncio.run(main())
  ```

  `aircloudy` is distributed under modified HL3 license. See `LICENSE.txt`.

  ```shell
  poetry run task lint
  ```
  ```shell
  poetry run task check
  ```
  ```shell
  poetry run task test
  ```
  ```shell
  poetry run task coverage
  ```
  ```shell
  poetry --build publish
  ```

  Not read/used field from notification :
  ```
  iduFrostWashStatus: IduFrostWashStatus
          active: bool
          priority: int
          astUpdatedA: int
          subCategory = None
          errorCode = None
  specialOperationStatus: SpecialOperationStatus
          active: bool
          priority: int
          lastUpdatedAt: int
          subCategory = None
          errorCode = None
  errorStatus: ErrorStatus
          active: bool
          priority: int
          lastUpdatedAt: int
          subCategory: str
          errorCode = None
  cloudId: str
  opt4: int
  holidayModeStatus: HolidayModeStatus
          active: bool
          priority: int
          lastUpdatedAt: int
          subCategory = None
          errorCode = None
  SysType: int
  ```
  Not read/used field from API:
  ```
  userId: str
  iduFrostWash: bool
  specialOperation: bool
  criticalError: bool
  zoneId: str
  ```


pkgId: 70be1e9989d2cc4fc9b5d2469f58d20db230b565142cbd691bacc8c68cef40f1
name: python-aircraft-design
arch: src
version: 0.0.17
epoch: 0
release: 1
summary: Condensed module for Aircraft Design
url: https://pypi.org/project/aircraft-design/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aircraft-design-0.0.17-1.src.rpm
checksum_type: sha256
description:
  Para instalar a biblioteca oficialmente, você pode usar o gerenciador de pacotes pip.
  A seguinte linha de comando pode ser executada no terminal ou prompt de comando:
  ```bash
  pip install aircraft-design
  ```
  Assim, a biblioteca será baixada e instalada em seu ambiente de desenvolvimento Python. Também é possível instalar a versão mais recente diretamente do repositório GitHub, executando o comando:
  ```bash
  pip install git+https://github.com/NisusAerodesign/aircraft-design.git
  ```
  Feito isso, já é possível importar e utilizar a biblioteca nas suas aplicações.


  Para instalar basta acessar pelo repositório da própria pipy[*](https://pypi.org/project/aircraft-design) e já estará pronto para uso.


  O projeto aircraft-design é um esforço desenvolvido por membros da equipe de competição **NISUS-aerodesign** com o objetivo de facilitar a análise de aeronaves. A equipe utiliza a ferramenta Vortex Lattice (ou malha de vórtices, em tradução livre), desenvolvida pelo MIT[*](https://web.mit.edu/drela/Public/web/avl/), para conduzir essas análises.

  A ferramenta Vortex Lattice permite que a equipe tenha uma visão detalhada das propriedades aerodinâmicas da aeronave, como por exemplo, a geração de sustentação, arrasto e forças de inclinação. Isso permite que a equipe faça melhorias no design da aeronave, tornando-a mais eficiente e segura para voo.

  [Repositório GitHub](https://github.com/NisusAerodesign/aircraft-design)


  A classe Wing (Asa) é responsável por criar superfícies aerodinâmicas, como asas e estabilizadores. Ela possui diversos parâmetros que podem ser ajustados para atender às necessidades específicas de cada projeto.

  A tabela abaixo apresenta cada um dos parâmetros da classe Wing, incluindo seu tipo de dado, valor padrão e se é obrigatório ou não:

  | Parâmetro       | Tipo de dado | Valor Padrão   |
  |:---------------:|:-----------:|:-------------:|
  | airfoil         | Path        | **Obrigatório** |
  | wingspan        | float       | **Obrigatório** |
  | mean_chord      | float       | **Obrigatório** |
  | taper_ratio     | float       |            1.0 |
  | transition_point| float       |            0.0 |
  | alpha_angle     | float       |            0.0 |
  | sweep_angle     | float       |            0.0 |
  | x_position      | float       |            0.0 |
  | y_position      | float       |            0.0 |
  | z_position      | float       |            0.0 |
  | align           | str         |           'LE' |
  | name            | str         |         'wing' |
  | control         | list        |         [None] |
  | panel_chordwise |int          |             10 |
  | panel_spanwise  |int          |             25 |

  Além disso, a classe Wing possui métodos *Getters* e *Setters* para todos os seus elementos, permitindo a manipulação de seus parâmetros de forma fácil e precisa. Também podemos encontrar outros métodos importantes, como `Wing().surface -> avl.Surface` e `Wing().reference_area() -> float`, que fornecem informações valiosas sobre a superfície da asa e sua área de referência.




  A biblioteca possui uma ferramenta de plotagem para melhor visualização da aeronave construída. Para utilizá-la, basta invocar o método plot() nas classes Wing e Aircraft.

  A tabela a seguir apresenta os parâmetros que podem ser especificados na função de plotagem:

  |Parâmetro|Tipo de dado              |Valor Padrão|
  |:-------:|:------------------------:|:----------:|
  |figure   |matplotlib.figure \| None |None        |
  |axis     |matplotlib.axis   \| None |None        |
  |linewidth| float                    | 1.0        |
  |color    |str                       |'black'     |

  Ambas as classes Wing e Aircraft podem receber uma figura e um eixo para se adequarem aos padrões de plotagem do usuário. Além disso, o plot gerado é tridimensional.



  A classe Aircraft é responsável por agrupar as superfícies aerodinâmicas e torná-las executáveis nos parâmetros da biblioteca de simulação de voo. Ela é um elemento fundamental para o projeto, pois permite a definição do avião como um todo, e é a partir dela que serão realizadas as simulações.

  Abaixo seguem os principais parâmetros que compõem a classe Aircraft:

  |Parâmetro      |Tipo de dado              |Valor Padrão   |
  |:-------------:|:------------------------:|:-------------:|
  |mach           | float                    |**Obrigatório**|
  |ground_effect  | float                    |**Obrigatório**|
  |reference_chord| float                    |**Obrigatório**|
  |reference_span | float                    |**Obrigatório**|
  |surfaces_list  | list                     |**Obrigatório**|
  |ref_point_x    | float                    | 0.0           |
  |ref_point_y    | float                    | 0.0           |
  |ref_point_z    | float                    | 0.0           |

  Além desses parâmetros, a classe Aircraft possui métodos Getters e Setters para todos eles, assim como outros métodos que podem ser necessários para realizar as simulações.


  Para poder executar a simulação deve ser gerada a geometria para poder ser executada.
  ```python
  Aircraft().geometry(name:str)
  ```

  A ferramenta de plotagem para o módulo **Aircraft** é totalmente compatível com o módulo **Wing**, recebendo os mesmos parâmetros.

  Verificar **1.1.**



  A classe Session é responsável por realizar a execução do código no AVL. Para fazer isso, é necessário que sejam fornecidos os seguintes parâmetros:

  |Parâmetro      |Tipo de dado              |Valor Padrão   |
  |:-------------:|:------------------------:|:-------------:|
  |geometry       | Aircraft.geometry        |**Obrigatório**|
  |cases          | Case \|None              |           None|
  |name           | str \|None               |           None|

  A variável `geometry` representa a geometria da aeronave, que será utilizada pelo AVL para realizar as análises. A variável `cases` é opcional e representa os casos de simulação que serão executados no AVL. Por fim, a variável `name` é também opcional e representa o nome da sessão que está sendo executada.

  Com esses parâmetros em mãos, a classe Session é capaz de realizar as simulações no AVL, gerando informações valiosas sobre o comportamento da aeronave em diferentes condições.



  A classe MultiSession é responsável por realizar a execução de múltiplas sessões no AVL utilizando uma abordagem paralela que aproveita a capacidade de processamento dos múltiplos núcleos da CPU.

  Para fazer isso, a classe MultiSession possui o seguinte parâmetro:

  |Parâmetro      |Tipo de dado                        |Valor Padrão   |
  |:-------------:|:----------------------------------:|:------------:|
  |session_array  | list[Session]                      |**Obrigatório**|

  A variável `session_array` representa a lista de sessões que serão executadas no AVL, que são objetos da classe `Session` com suas respectivas geometrias e casos de simulação.

  A classe MultiSession é responsável por gerenciar os Workers, compartilhar a memória entre eles e organizar as filas de execução das sessões. Dessa forma, a classe MultiSession permite que múltiplas sessões sejam executadas em paralelo, aumentando a eficiência do processo de simulação.

  A utilização da classe MultiSession é recomendada quando o número de sessões é maior ou igual ao dobro do número de núcleos da CPU, para que seja possível obter o máximo aproveitamento da capacidade de processamento do hardware.


pkgId: bce3c84bcc0e0bfc7a37090a3c1975a812e31dd11cbea8aa735ce3157317d036
name: python-airduct
arch: src
version: 0.1.22
epoch: 0
release: 1
summary: Simple Pipeline Scheduler in Python
url: https://github.com/alairock/airduct
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airduct-0.1.22-1.src.rpm
checksum_type: sha256
description:
  Simple Pipeline Scheduler in Python

  ![Airduct Screenshot](docs/screenshot.png)



  - [Github](https://github.com/alairock/airduct)
  - [Documentation](https://airduct.readthedocs.io)


      $ pip install airduct

  or

      $ poetry add airduct



  Create a file and put into a folder/python-module.

  ```python
  from airduct import schedule, task


  schedule(
      name='ExampleFlow',
      run_at='* * * * *',
      flow=[
          task('e1f1'),
          [task('e1f2'), task('e1f3', can_fail=True)],
          [task('e1f4')]
      ]
  )

  async def e1f1():
      print('e1f1 - An async function!')

  def e1f2():
      print('e1f2 - Regular functions work too')

  async def e1f3():
      print('e1f3')

  async def e1f4():
      print('e1f4')
  ```

  Run: `$ airduct schedule --path /path/to/folder`

  By default it uses a sqlite in-memory database. If using the in-memory database, it will also automatically run as a worker, in addition to a scheduler. If you wish to use a non in-memory sqlite database, you will need to also run a worker (could be on same box, or separate) See the documentation for more info.


pkgId: fb365f00d749fb9e465ceebc96f8edb7980176c82e9bb86ef3d5852ad4e03080
name: python-airflint
arch: src
version: 0.3.2a0
epoch: 0
release: 1
summary: Enforce Best Practices for all your Airflow DAGs. ⭐
url: https://pypi.org/project/airflint/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflint-0.3.2a0-1.src.rpm
checksum_type: sha256
description:
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/feluelle/airflint/main.svg)](https://results.pre-commit.ci/latest/github/feluelle/airflint/main)
  ![test workflow](https://github.com/feluelle/airflint/actions/workflows/test.yml/badge.svg)
  ![codeql-analysis workflow](https://github.com/feluelle/airflint/actions/workflows/codeql-analysis.yml/badge.svg)
  [![codecov](https://codecov.io/gh/feluelle/airflint/branch/main/graph/badge.svg?token=J8UEP8IVY4)](https://codecov.io/gh/feluelle/airflint)
  [![PyPI version](https://img.shields.io/pypi/v/airflint)](https://pypi.org/project/airflint/)
  [![License](https://img.shields.io/pypi/l/airflint)](https://github.com/feluelle/airflint/blob/main/LICENSE)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/airflint)](https://pypi.org/project/airflint/)
  [![PyPI version](https://img.shields.io/pypi/dm/airflint)](https://pypi.org/project/airflint/)

  > Enforce Best Practices for all your Airflow DAGs. ⭐

  ⚠️ **airflint is still in alpha stage and has not been tested with real world Airflow DAGs. Please report any issues you face via [GitHub Issues](https://github.com/feluelle/airflint/issues), thank you. 🙏**



  - [x] Use function-level imports instead of top-level imports[^1][^2] (see [Top level Python Code](https://airflow.apache.org/docs/apache-airflow/stable/best-practices.html#top-level-python-code))
  - [x] Use jinja template syntax instead of `Variable.get` (see [Airflow Variables](https://airflow.apache.org/docs/apache-airflow/stable/best-practices.html#airflow-variables))

  [^1]: There is a PEP for [Lazy Imports](https://peps.python.org/pep-0690/) targeted to arrive in Python 3.12 which would supersede this rule.

  [^2]: To remove top-level imports after running `UseFunctionLevelImports` rule, use a tool such as [autoflake](https://github.com/PyCQA/autoflake).

  _based on official [Best Practices](https://airflow.apache.org/docs/apache-airflow/stable/best-practices.html)_



  airflint is tested with:

  |                | Main version (dev)               | Released version (0.3.1-alpha) |
  |----------------|----------------------------------|--------------------------------|
  | Python         | 3.9, 3.10, 3.11.0-alpha - 3.11.0 | 3.9, 3.10                      |
  | Apache Airflow | >= 2.0.0                         | >= 2.3.0                       |



  To install it from [PyPI](https://pypi.org/) run:

  ```console
  pip install airflint
  ```

  > **_NOTE:_** It is recommended to install airflint into your existing airflow environment with all your providers included. This way `UseJinjaVariableGet` rule can detect all `template_fields` and airflint works as expected.

  Then just call it like this:

  ![usage](assets/images/usage.png)



  Alternatively you can add the following repo to your `pre-commit-config.yaml`:

  ```yaml
    - repo: https://github.com/feluelle/airflint
      rev: v0.3.1-alpha
      hooks:
        - id: airflint
          args: ["-a"]  # Use -a to apply the suggestions
          additional_dependencies:  # Add all package dependencies you have in your dags, preferable with version spec
            - apache-airflow
            - apache-airflow-providers-cncf-kubernetes
  ```

  To complete the `UseFunctionlevelImports` rule, please add the `autoflake` hook after the `airflint` hook, as below:

  ```yaml
    - repo: https://github.com/pycqa/autoflake
      rev: v1.4
      hooks:
        - id: autoflake
          args: ["--remove-all-unused-imports", "--in-place"]
  ```

  This will remove unused imports.



  I am looking for contributors who are interested in..

  - testing airflint with real world Airflow DAGs and reporting issues as soon as they face them
  - optimizing the ast traversing for existing rules
  - adding new rules based on best practices or bottlenecks you have experienced during Airflow DAGs authoring
  - documenting about what is being supported in particular by each rule
  - defining supported airflow versions i.e. some rules are bound to specific Airflow features and version

  For questions, please don't hesitate to open a GitHub issue.


pkgId: 1135ec412a3ba88128c1c742662f19cb0772a70a3a76edc0fc89930387e2ecc1
name: python-airflow-code-editor
arch: src
version: 7.7.0
epoch: 0
release: 1
summary: Apache Airflow code editor and file manager
url: https://github.com/andreax79/airflow-code-editor
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-code-editor-7.7.0-1.src.rpm
checksum_type: sha256
description:
  This plugin for [Apache Airflow](https://github.com/apache/airflow) allows you to edit DAGs directly within your browser,
  providing a seamless and efficient workflow for managing your pipelines.
  Offering a user-friendly file management interface within designated directories, it facilitates effortless editing,
  uploading, and downloading of files.
  With Git support enabled, DAGs are stored in a Git repository, enabling users to explore Git history, review local modifications, and commit changes.

  [![Build Status](https://github.com/andreax79/airflow-code-editor/workflows/Tests/badge.svg)](https://github.com/andreax79/airflow-code-editor/actions)
  [![PyPI version](https://badge.fury.io/py/airflow-code-editor.svg)](https://badge.fury.io/py/airflow-code-editor)
  [![PyPI](https://img.shields.io/pypi/pyversions/airflow-code-editor.svg)](https://pypi.org/project/airflow-code-editor)
  [![Downloads](https://static.pepy.tech/badge/airflow-code-editor/month)](https://pepy.tech/project/airflow-code-editor)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  * Airflow Versions
      * 1.10.3 or newer
  * git Versions (git is not required if git support is disabled)
      * 2.0 or newer





  ![File Manager](https://github.com/andreax79/airflow-code-editor/assets/1288154/6d9b09df-4503-45d9-94d4-ff013a86985a)



  ![Editor](https://github.com/andreax79/airflow-code-editor/assets/1288154/4ffaed29-390f-4134-bcb4-0b8fb8c59060)



  ![Search](https://github.com/andreax79/airflow-code-editor/assets/1288154/9ba81166-3823-40ae-8820-116e4e5d2588)



  ![Git History](https://github.com/andreax79/airflow-code-editor/assets/1288154/2d6ec31f-3c1c-4d38-8fc6-99d18096cc64)



  ![Git Workspace](https://github.com/andreax79/airflow-code-editor/assets/1288154/eb041a02-3f1e-47a1-b179-072d66e4662d)






  For the ease of deployment, use the production-ready reference container image.
  The image is based on the reference images for Apache Airflow.

  You can find the following images there:
  * andreax79/airflow-code-editor:**latest** - the latest released Airflow Code Editor image with the latest Apache Airflow version
  * andreax79/airflow-code-editor:**2.10.0** - the latest released Airflow Code Editor with specific Airflow version
  * andreax79/airflow-code-editor:**2.10.0-7.7.0** - specific version of Airflow and Airflow Code Editor



  1. Install the plugin

    ```bash
      pip install airflow-code-editor
    ```

  2. Install optional dependencies

  * black - Black Python code formatter
  * isort - A Python utility/library to sort imports
  * fs-s3fs - S3FS Amazon S3 Filesystem
  * fs-gcsfs - Google Cloud Storage Filesystem
  * ... other filesystems supported by PyFilesystem - see https://www.pyfilesystem.org/page/index-of-filesystems/

    ```bash
      pip install black isort fs-s3fs fs-gcsfs
    ```

  3. Restart the Airflow Web Server

  4. Open Admin - DAGs Code Editor




  You can set options editing the Airflow's configuration file or setting environment variables.
  You can edit your *airflow.cfg* adding any of the following settings in the \[code_editor\] section.
  All the settings are optional.

  * **enabled**  enable this plugin (default: True).
  * **git_enabled**  enable git support (default: True). If git is not installed, disable this option.
  * **git_cmd**  git command (path)
  * **git_default_args**  git arguments added to each call (default: -c color.ui=true)
  * **git_author_name** human-readable name in the author/committer (default logged user first and last names)
  * **git_author_email** email for the author/committer (default: logged user email)
  * **git_init_repo**  initialize a git repo in DAGs folder (default: True)
  * **root_directory**  root folder (default: Airflow DAGs folder)
  * **line_length**  Python code formatter - max line length (default: 88)
  * **string_normalization**  Python code formatter - if true normalize string quotes and prefixes (default: False)
  * **mount**, **mount1**, ...  configure additional folder (mount point) - format: name=xxx,path=yyy
  * **ignored_entries** comma-separated list of entries to be excluded from file/directory list (default: .\*,\_\_pycache\_\_)

  ```
     [code_editor]
     enabled = True
     git_enabled = True
     git_cmd = /usr/bin/git
     git_default_args = -c color.ui=true
     git_init_repo = False
     root_directory = /home/airflow/dags
     line_length = 88
     string_normalization = False
     mount = name=data,path=/home/airflow/data
     mount1 = name=logs,path=/home/airflow/logs
     mount2 = name=data,path=s3://example
  ```

  Mount Options:

  * **name**: mount name (destination)
  * **path**: local path or PyFilesystem FS URLs - see https://docs.pyfilesystem.org/en/latest/openers.html

  Example:
  * name=ftp_server,path=ftp://user:pass@ftp.example.org/private
  * name=data,path=s3://example
  * name=tmp,path=/tmp

  You can also set options with the following environment variables:

  * AIRFLOW__CODE_EDITOR__ENABLED
  * AIRFLOW__CODE_EDITOR__GIT_ENABLED
  * AIRFLOW__CODE_EDITOR__GIT_CMD
  * AIRFLOW__CODE_EDITOR__GIT_DEFAULT_ARGS
  * AIRFLOW__CODE_EDITOR__GIT_AUTHOR_NAME
  * AIRFLOW__CODE_EDITOR__GIT_AUTHOR_EMAIL
  * AIRFLOW__CODE_EDITOR__GIT_INIT_REPO
  * AIRFLOW__CODE_EDITOR__ROOT_DIRECTORY
  * AIRFLOW__CODE_EDITOR__LINE_LENGTH
  * AIRFLOW__CODE_EDITOR__STRING_NORMALIZATION
  * AIRFLOW__CODE_EDITOR__MOUNT, AIRFLOW__CODE_EDITOR__MOUNT1, AIRFLOW__CODE_EDITOR__MOUNT2, ...
  * AIRFLOW__CODE_EDITOR__IGNORED_ENTRIES

  Example:
  ```
     export AIRFLOW__CODE_EDITOR__STRING_NORMALIZATION=True
     export AIRFLOW__CODE_EDITOR__MOUNT='name=data,path=/home/airflow/data'
     export AIRFLOW__CODE_EDITOR__MOUNT1='name=logs,path=/home/airflow/logs'
     export AIRFLOW__CODE_EDITOR__MOUNT2='name=tmp,path=/tmp'
  ```



  Airflow Code Editor provides a REST API. Through this API, users can interact with the application
  programmatically, enabling automation, data retrieval, and integration with other software.

  For detailed information on how to use each endpoint, refer to the
  [API documentation](https://petstore.swagger.io/?url=https://raw.githubusercontent.com/andreax79/airflow-code-editor/main/airflow_code_editor/api/code_editor.yaml).



  The API authentication is inherited from the Apache Airflow.

  If you want to check which auth backend is currently set, you can use
  `airflow config get-value api auth_backends` command as in the example below.
  ```bash
  $ airflow config get-value api auth_backends
  airflow.api.auth.backend.basic_auth
  ```

  For details on configuring the authentication, see
  [API Authorization](https://airflow.apache.org/docs/apache-airflow/stable/security/api.html).



  1. Fork the repo

  2. Clone it on the local machine

    ```bash
      git clone https://github.com/andreax79/airflow-code-editor.git
      cd airflow-code-editor
    ```

  3. Create dev image

    ```bash
      make dev-image
    ```

  4. Switch node version

    ```bash
      nvm use
    ```

  5. Make changes you need. Build npm package with:

    ```bash
      make npm-build
    ```

  6. You can start Airflow webserver with:

    ```bash
      make webserver
    ```

  7. Run tests

    ```bash
      make test
    ```

  8. Commit and push changes

  9. Create [pull request](https://github.com/andreax79/airflow-code-editor/compare) to the original repo



  * [Apache Airflow](https://github.com/apache/airflow)
  * [Codemirror, In-browser code editor](https://github.com/codemirror/codemirror)
  * [Git WebUI, A standalone local web based user interface for git repositories](https://github.com/alberthier/git-webui)
  * [Black, The Uncompromising Code Formatter](https://github.com/psf/black)
  * [isort, A Python utility/library to sort imports](https://github.com/psf/black)
  * [pss, power-tool for searching source files](https://github.com/eliben/pss)
  * [Vue.js](https://github.com/vuejs/vue)
  * [Vue-good-table, data table for VueJS](https://github.com/xaksis/vue-good-table)
  * [Vue-tree, TreeView control for VueJS](https://github.com/grapoza/vue-tree)
  * [Vue-universal-modal Universal modal plugin for Vue@3](https://github.com/hoiheart/vue-universal-modal)
  * [Vue-simple-context-menu](https://github.com/johndatserakis/vue-simple-context-menu)
  * [Splitpanes](https://github.com/antoniandre/splitpanes)
  * [Axios, Promise based HTTP client for the browser and node.js](https://github.com/axios/axios)
  * [PyFilesystem2, Python's Filesystem abstraction layer](https://github.com/PyFilesystem/pyfilesystem2)
  * [Amazon S3 PyFilesystem](https://github.com/PyFilesystem/s3fs)
  * [Google Cloud Storage PyFilesystem](https://github.com/Othoz/gcsfs)


pkgId: 761d280ffc8c11ebfb23372728055b0a035baf973d7b34eda04d7ff2fde1ec30
name: python-airflow-customs-by-novigi
arch: src
version: 1.0.23
epoch: 0
release: 1
summary: Novigi Custom Airflow operators, hooks and plugins
url: https://pypi.org/project/airflow-customs-by-novigi/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-customs-by-novigi-1.0.23-1.src.rpm
checksum_type: sha256
description:
  * This Repo mainly contains custom airflow operators and hooks which were writen by Novigi Pty Ltd
  * Version No - 1.0.10
  * Bitbucket Link - https://bitbucket.org/novigi/nov20011-airflow-common-extensions/src/master/




  * Open a terminal and just type "sudo pip install airflow_customs_by_novigi"




  * integration@novigi.com.au


pkgId: 3ac5993df34e9e7a994492dd309da4e967f95ef25bad98d3c40bd507fe977f8e
name: python-airflow-dag
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A tool to manage Airflow dags.
url: https://github.com/vinayak-mehta/airflow-dag
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-dag-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A tool to manage Airflow dags.



  You can use `pip` to install `airflow-dag`:

  ```
  $ pip install airflow-dag
  ```



  You can use the `build` command to convert a yaml config to an Airflow dag:

  ```
  $ airflow-dag build -t examples/ -c examples/notebook.yml -o examples/out
  ```

  ```
  $ airflow-dag build --help
  Usage: airflow-dag build [OPTIONS]

    Convert a yaml config to an Airflow dag.

  Options:
    -t, --template-dir TEXT  Path to dag templates
    -c, --config TEXT        Path to dag config
    -o, --output-dir TEXT    Output path
    --help                   Show this message and exit.
  ```

  If a template path is not provided, `airflow-dag` will look into the [default templates](https://github.com/vinayak-mehta/airflow-dag/blob/main/src/airflow_dag/templates).

  You can define your own dag templates too, and put them in a `templates` directory in Airflow's home folder. The dag yaml configs can be placed in a `configs` directory in the same home folder, and the output path can then be the Airflow dags folder. The usage will look like:

  ```
  $ airflow-dag build -t airflow/templates -c airflow/configs/dag.yml -o airflow/dags
  ```



  `airflow-dag` uses [Semantic Versioning](https://semver.org/). For the available versions, see the tags on the GitHub repository.



  This project is licensed under the Apache License, see the [LICENSE](https://github.com/vinayak-mehta/airflow-dag/blob/master/LICENSE) file for details.


pkgId: 06813be0ba7e17304a9434566636d8d5692397c9281141e5366839de6c6646c2
name: python-airflow-dbt
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Apache Airflow integration for dbt
url: https://github.com/gocardless/airflow-dbt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-dbt-0.4.0-1.src.rpm
checksum_type: sha256
description:
  This is a collection of [Airflow](https://airflow.apache.org/) operators to provide easy integration with [dbt](https://www.getdbt.com).

  ```py
  from airflow import DAG
  from airflow_dbt.operators.dbt_operator import (
      DbtSeedOperator,
      DbtSnapshotOperator,
      DbtRunOperator,
      DbtTestOperator
  )
  from airflow.utils.dates import days_ago

  default_args = {
    'dir': '/srv/app/dbt',
    'start_date': days_ago(0)
  }

  with DAG(dag_id='dbt', default_args=default_args, schedule_interval='@daily') as dag:

    dbt_seed = DbtSeedOperator(
      task_id='dbt_seed',
    )

    dbt_snapshot = DbtSnapshotOperator(
      task_id='dbt_snapshot',
    )

    dbt_run = DbtRunOperator(
      task_id='dbt_run',
    )

    dbt_test = DbtTestOperator(
      task_id='dbt_test',
      retries=0,  # Failing tests would fail the task, and we don't want Airflow to try again
    )

    dbt_seed >> dbt_snapshot >> dbt_run >> dbt_test
  ```



  Install from PyPI:

  ```sh
  pip install airflow-dbt
  ```

  It will also need access to the `dbt` CLI, which should either be on your `PATH` or can be set with the `dbt_bin` argument in each operator.



  There are five operators currently implemented:

  * `DbtDocsGenerateOperator`
    * Calls [`dbt docs generate`](https://docs.getdbt.com/reference/commands/cmd-docs)
  * `DbtDepsOperator`
    * Calls [`dbt deps`](https://docs.getdbt.com/docs/deps)
  * `DbtSeedOperator`
    * Calls [`dbt seed`](https://docs.getdbt.com/docs/seed)
  * `DbtSnapshotOperator`
    * Calls [`dbt snapshot`](https://docs.getdbt.com/docs/snapshot)
  * `DbtRunOperator`
    * Calls [`dbt run`](https://docs.getdbt.com/docs/run)
  * `DbtTestOperator`
    * Calls [`dbt test`](https://docs.getdbt.com/docs/test)


  Each of the above operators accept the following arguments:

  * `profiles_dir`
    * If set, passed as the `--profiles-dir` argument to the `dbt` command
  * `target`
    * If set, passed as the `--target` argument to the `dbt` command
  * `dir`
    * The directory to run the `dbt` command in
  * `full_refresh`
    * If set to `True`, passes `--full-refresh`
  * `vars`
    * If set, passed as the `--vars` argument to the `dbt` command. Should be set as a Python dictionary, as will be passed to the `dbt` command as YAML
  * `models`
    * If set, passed as the `--models` argument to the `dbt` command
  * `exclude`
    * If set, passed as the `--exclude` argument to the `dbt` command
  * `select`
    * If set, passed as the `--select` argument to the `dbt` command
  * `dbt_bin`
    * The `dbt` CLI. Defaults to `dbt`, so assumes it's on your `PATH`
  * `verbose`
    * The operator will log verbosely to the Airflow logs
  * `warn_error`
    * If set to `True`, passes `--warn-error` argument to `dbt` command and will treat warnings as errors

  Typically you will want to use the `DbtRunOperator`, followed by the `DbtTestOperator`, as shown earlier.

  You can also use the hook directly. Typically this can be used for when you need to combine the `dbt` command with another task in the same operators, for example running `dbt docs` and uploading the docs to somewhere they can be served from.



  To install from the repository:
  First it's recommended to create a virtual environment:
  ```bash
  python3 -m venv .venv

  source .venv/bin/activate
  ```

  Install using `pip`:
  ```bash
  pip install .
  ```



  To run tests locally, first create a virtual environment (see [Building Locally](https://github.com/gocardless/airflow-dbt#building-locally) section)

  Install dependencies:
  ```bash
  pip install . pytest
  ```

  Run the tests:
  ```bash
  pytest tests/
  ```


  This project uses [flake8](https://flake8.pycqa.org/en/latest/).

  To check your code, first create a virtual environment (see [Building Locally](https://github.com/gocardless/airflow-dbt#building-locally) section):
  ```bash
  pip install flake8
  flake8 airflow_dbt/ tests/ setup.py
  ```



  If you use dbt's package manager you should include all dependencies before deploying your dbt project.

  For Docker users, packages specified in `packages.yml` should be included as part your docker image by calling `dbt deps` in your `Dockerfile`.



  If you use MWAA, you just need to update the `requirements.txt` file and add `airflow-dbt` and `dbt` to it.

  Then you can have your dbt code inside a folder `{DBT_FOLDER}` in the dags folder on S3 and configure the dbt task like below:

  ```python
  dbt_run = DbtRunOperator(
    task_id='dbt_run',
    dbt_bin='/usr/local/airflow/.local/bin/dbt',
    profiles_dir='/usr/local/airflow/dags/{DBT_FOLDER}/',
    dir='/usr/local/airflow/dags/{DBT_FOLDER}/'
  )
  ```



  * This is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
  * Bug reports and pull requests are welcome on GitHub at https://github.com/gocardless/airflow-dbt.

  GoCardless ♥ open source. If you do too, come [join us](https://gocardless.com/about/jobs).


pkgId: 6e727da3c419008b5ae6bbfc0976cb9313c2986a9394c80ed623531874a395bd
name: python-airflow-dbt-python
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: A collection of Airflow operators, hooks, and utilities to execute dbt commands
url: https://github.com/tomasfarias/airflow-dbt-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-dbt-python-2.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/airflow-dbt-python?style=plastic)](https://pypi.org/project/airflow-dbt-python/)
  [![CI testing](https://github.com/tomasfarias/airflow-dbt-python/actions/workflows/ci.yaml/badge.svg)](https://github.com/tomasfarias/airflow-dbt-python/actions)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Test coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/tomasfarias/81ef37701aa088d18db8a58ce07c79c7/raw/covbadge.json)](https://github.com/tomasfarias/airflow-dbt-python/actions)
  [![Documentation](https://readthedocs.org/projects/airflow-dbt-python/badge/?version=latest)](https://airflow-dbt-python.readthedocs.io/en/latest/?badge=latest)

  A collection of [Airflow](https://airflow.apache.org/) operators, hooks, and utilities to execute [`dbt`](https://pypi.org/project/dbt-core/) commands.

  Read the [documentation](https://airflow-dbt-python.readthedocs.io) for examples, installation instructions, and more details.





  Before using *airflow-dbt-python*, ensure you meet the following requirements:
  * A *dbt* project using [dbt-core](https://pypi.org/project/dbt-core/) version 1.7.5 or later.
  * An Airflow environment using version 2.7 or later.

    * If using any managed service, like AWS MWAA or GCP Cloud Composer 2/3, ensure your environment is created with a supported version of Airflow.
    * If self-hosting, Airflow installation instructions can be found in their [official documentation](https://airflow.apache.org/docs/apache-airflow/stable/installation/index.html).

  * Running Python 3.8 or later in your Airflow environment.

  > **Warning**
  >
  > Even though we don't impose any upper limits on versions of Airflow and *dbt*, it's possible that new versions are not supported immediately after release, particularly for *dbt*. We recommend testing the latest versions before upgrading and [reporting any issues](https://github.com/tomasfarias/airflow-dbt-python/issues/new/choose).

  > **Note**
  >
  > Older versions of Airflow and *dbt* may work with *airflow-dbt-python*, although we cannot guarantee this. Our testing pipeline runs the latest *dbt-core* with the latest Airflow release, and the latest version supported by [AWS MWAA](https://aws.amazon.com/managed-workflows-for-apache-airflow/) and [GCP Cloud Composer 2/3](https://aws.amazon.com/managed-workflows-for-apache-airflow/).



  *airflow-dbt-python* is available in [PyPI](https://pypi.org/project/airflow-dbt-python/) and can be installed with *pip*:

  ``` shell
  pip install airflow-dbt-python
  ```

  As a convenience, some *dbt* adapters can be installed by specifying extras. For example, if requiring the *dbt-redshift* adapter:

  ``` shell
  pip install airflow-dbt-python[redshift]
  ```



  *airflow-dbt-python* can also be built from source by cloning this GitHub repository:

  ``` shell
  git clone https://github.com/tomasfarias/airflow-dbt-python.git
  cd airflow-dbt-python
  ```

  And installing with *Poetry*:

  ``` shell
  poetry install
  ```



  Add *airflow-dbt-python* to your `requirements.txt` file and edit your Airflow environment to use this new `requirements.txt` file, or upload it as a plugin.

  Read the [documentation](https://airflow-dbt-python.readthedocs.io/en/latest/getting_started.html#installing-in-mwaa) for more a more detailed AWS MWAA installation breakdown.



  Add *airflow-dbt-python* to your PyPI packages list.

  Read the [documentation](https://cloud.google.com/composer/docs/composer-2/install-python-dependencies#install-pypi) for more a more detailed GCP Cloud Composer 2 installation breakdown.



  *airflow-dbt-python* should be compatible with most or all Airflow managed services. Consult the documentation specific to your provider.

  If you notice an issue when installing *airflow-dbt-python* in a specific managed service, please open an [issue](https://github.com/tomasfarias/airflow-dbt-python/issues/new/choose).



  *airflow-dbt-python* aims to make dbt a **first-class citizen** of Airflow by supporting additional features that integrate both tools. As you would expect, *airflow-dbt-python* can run all your dbt workflows in Airflow with the same interface you are used to from the CLI, but without being a mere wrapper: *airflow-dbt-python* directly communicates with internal *dbt-core* classes, bridging the gap between them and Airflow's operator interface. Essentially, we are attempting to use *dbt* **as a library**.

  As this integration was completed, several features were developed to **extend the capabilities of dbt** to leverage Airflow as much as possible. Can you think of a way *dbt* could leverage Airflow that is not currently supported? Let us know in a [GitHub issue](https://github.com/tomasfarias/airflow-dbt-python/issues/new/choose)!



  Airflow executes [Tasks](https://airflow.apache.org/docs/apache-airflow/stable/concepts/tasks.html) independent of one another: even though downstream and upstream dependencies between tasks exist, the execution of an individual task happens entirely independently of any other task execution (see: [Tasks Relationships](https://airflow.apache.org/docs/apache-airflow/stable/concepts/tasks.html#relationships)).

  In order to work with this constraint, *airflow-dbt-python* runs each dbt command in a **temporary and isolated directory**. Before execution, all the relevant dbt files are copied from supported backends, and after executing the command any artifacts are exported. This ensures dbt can work with any Airflow deployment, including most production deployments as they are usually running [Remote Executors](https://airflow.apache.org/docs/apache-airflow/stable/executor/index.html#executor-types) and do not guarantee any files will be shared by default between tasks, since each task may run in a completely different environment.




  The dbt parameters `profiles_dir` and `project_dir` would normally point to a directory containing a `profiles.yml` file and a dbt project in the local environment respectively (defined by the presence of a *dbt_project.yml* file). *airflow-dbt-python* extends these parameters to also accept an URL pointing to a remote storage.

  Currently, we support the following remote storages:

  * [AWS S3](https://aws.amazon.com/s3/) (identified by a *s3* scheme).
  * Remote git repositories, like those stored in GitHub (both *https* and *ssh* schemes are supported).

  * If a remote URL is used for `project_dir`, then this URL must point to a location in your remote storage containing a *dbt* project to run. A *dbt* project is identified by the prescence of a *dbt_project.yml*, and contains all your [resources](https://docs.getdbt.com/docs/build/projects). All of the contents of this remote location will be downloaded and made available for the operator. The URL may also point to an archived file containing all the files of a dbt project, which will be downloaded, uncompressed, and made available for the operator.
  * If a remote URL is used for `profiles_dir`, then this URL must point to a location in your remote storage that contains a *profiles.yml* file. The *profiles.yml* file will be downloaded and made available for the operator to use when running. The *profiles.yml* may be part of your *dbt* project, in which case this argument may be ommitted.

  This feature is intended to work in line with Airflow's [description of the task concept](https://airflow.apache.org/docs/apache-airflow/stable/concepts/tasks.html#relationships):

  > Tasks don’t pass information to each other by default, and run entirely independently.

  We interpret this as meaning a task should be responsible of fetching all the *dbt* related files it needs in order to run independently, as already described in [Independent Task Execution](#independent-task-execution).



  Each dbt execution produces one or more [JSON artifacts](https://docs.getdbt.com/reference/artifacts/dbt-artifacts/) that are valuable to produce meta-metrics, build conditional workflows, for reporting purposes, and other uses. *airflow-dbt-python* can push these artifacts to [XCom](https://airflow.apache.org/docs/apache-airflow/stable/concepts/xcoms.html) as requested via the `do_xcom_push_artifacts` parameter, which takes a list of artifacts to push.



  [Airflow connections](https://airflow.apache.org/docs/apache-airflow/stable/howto/connection.html) allow users to manage and store connection information, such as hostname, port, username, and password, for operators to use when accessing certain applications, like databases. Similarly, a *dbt* `profiles.yml` file stores connection information under each target key. *airflow-dbt-python* bridges the gap between the two and allows you to use connection information stored as an Airflow connection by specifying the connection id as the `target` parameter of any of the *dbt* operators it provides. What's more, if using an Airflow connection, the `profiles.yml` file may be entirely omitted (although keep in mind a `profiles.yml` file contains a configuration block besides target connection information).

  See an example DAG [here](examples/airflow_connection_target_dag.py).





  Although [`dbt`](https://docs.getdbt.com/) is meant to be installed and used as a CLI, we may not have control of the environment where Airflow is running, disallowing us the option of using *dbt* as a CLI.

  This is exactly what happens when using [Amazon's Managed Workflows for Apache Airflow](https://aws.amazon.com/managed-workflows-for-apache-airflow/) (aka MWAA): although a list of Python requirements can be passed, the CLI cannot be found in the worker's PATH.

  There is a workaround which involves using Airflow's `BashOperator` and running Python from the command line:

  ``` python
  from airflow.operators.bash import BashOperator

  BASH_COMMAND = "python -c 'from dbt.main import main; main()' run"
  operator = BashOperator(
      task_id="dbt_run",
      bash_command=BASH_COMMAND,
  )
  ```

  But it can get cumbersome when appending all potential arguments a `dbt run` command (or other subcommand) can take.

  That's where *airflow-dbt-python* comes in: it abstracts the complexity of interfacing with *dbt-core* and exposes one operator for each *dbt* subcommand that can be instantiated with all the corresponding arguments that the *dbt* CLI would take.



  The alternative [`airflow-dbt`](https://pypi.org/project/airflow-dbt/) package, by default, would not work if the *dbt* CLI is not in PATH, which means it would not be usable in MWAA. There is a workaround via the `dbt_bin` argument, which can be set to `"python -c 'from dbt.main import main; main()' run"`, in similar fashion as the `BashOperator` example. Yet this approach is not without its limitations:
  * *airflow-dbt* works by wrapping the *dbt* CLI, which makes our code dependent on the environment in which it runs.
  * *airflow-dbt* does not support the full range of arguments a command can take. For example, `DbtRunOperator` does not have an attribute for `fail_fast`.
  * *airflow-dbt* does not offer access to *dbt* artifacts created during execution. *airflow-dbt-python* does so by pushing any artifacts to [XCom](https://airflow.apache.org/docs/apache-airflow/stable/concepts/xcoms.html).



  Currently, the following *dbt* commands are supported:

  * `clean`
  * `compile`
  * `debug`
  * `deps`
  * `docs generate`
  * `ls`
  * `parse`
  * `run`
  * `run-operation`
  * `seed`
  * `snapshot`
  * `source`
  * `test`



  All example DAGs are tested against the latest Airflow version. Some changes, like modifying `import` statements or changing types, may be required for them to work in other versions.

  ``` python
  import datetime as dt

  import pendulum
  from airflow import DAG

  from airflow_dbt_python.operators.dbt import (
      DbtRunOperator,
      DbtSeedOperator,
      DbtTestOperator,
  )

  args = {
      "owner": "airflow",
  }

  with DAG(
      dag_id="example_dbt_operator",
      default_args=args,
      schedule="0 0 * * *",
      start_date=pendulum.today("UTC").add(days=-1),
      dagrun_timeout=dt.timedelta(minutes=60),
      tags=["example", "example2"],
  ) as dag:
      dbt_test = DbtTestOperator(
          task_id="dbt_test",
          selector_name="pre-run-tests",
      )

      dbt_seed = DbtSeedOperator(
          task_id="dbt_seed",
          select=["/path/to/first.csv", "/path/to/second.csv"],
          full_refresh=True,
      )

      dbt_run = DbtRunOperator(
          task_id="dbt_run",
          select=["/path/to/models"],
          full_refresh=True,
          fail_fast=True,
      )

      dbt_test >> dbt_seed >> dbt_run
  ```

  More examples can be found in the [`examples/`](examples/) directory and the [documentation](https://airflow-dbt-python.readthedocs.io).



  See the [development documentation](https://airflow-dbt-python.readthedocs.io/en/latest/development.html) for a more in-depth dive into setting up a development environment, running the test-suite, and general commentary on working on *airflow-dbt-python*.



  Tests are run with *pytest*, can be located in `tests/`. To run them locally, you may use *Poetry*:

  ``` shell
  poetry run pytest tests/ -vv
  ```



  This project is licensed under the MIT license. See [LICENSE](LICENSE).


pkgId: 5235b1b8529257bd463a86cc35537a6a51cd61a6905313d62711beb2a61a8f29
name: python-airflow-dbt-winwin
arch: src
version: 0.5.12
epoch: 0
release: 1
summary: Apache Airflow integration for dbt
url: https://github.com/gocardless/airflow-dbt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-dbt-winwin-0.5.12-1.src.rpm
checksum_type: sha256
description:
  This is a collection of [Airflow](https://airflow.apache.org/) operators to provide easy integration with [dbt](https://www.getdbt.com).

  ```py
  from airflow import DAG
  from airflow_dbt.operators.dbt_operator import (
      DbtSeedOperator,
      DbtSnapshotOperator,
      DbtRunOperator,
      DbtTestOperator,
      DbtCleanOperator,
  )
  from airflow.utils.dates import days_ago

  default_args = {
    'dir': '/srv/app/dbt',
    'start_date': days_ago(0)
  }

  with DAG(dag_id='dbt', default_args=default_args, schedule_interval='@daily') as dag:

    dbt_seed = DbtSeedOperator(
      task_id='dbt_seed',
    )

    dbt_snapshot = DbtSnapshotOperator(
      task_id='dbt_snapshot',
    )

    dbt_run = DbtRunOperator(
      task_id='dbt_run',
    )

    dbt_test = DbtTestOperator(
      task_id='dbt_test',
      retries=0,  # Failing tests would fail the task, and we don't want Airflow to try again
    )

    dbt_clean = DbtCleanOperator(
      task_id='dbt_clean',
    )

    dbt_seed >> dbt_snapshot >> dbt_run >> dbt_test >> dbt_clean
  ```



  Install from PyPI:

  ```sh
  pip install airflow-dbt-winwin
  ```

  It will also need access to the `dbt` CLI, which should either be on your `PATH` or can be set with the `dbt_bin` argument in each operator.



  There are five operators currently implemented:

  * `DbtDocsGenerateOperator`
    * Calls [`dbt docs generate`](https://docs.getdbt.com/reference/commands/cmd-docs)
  * `DbtDepsOperator`
    * Calls [`dbt deps`](https://docs.getdbt.com/docs/deps)
  * `DbtSeedOperator`
    * Calls [`dbt seed`](https://docs.getdbt.com/docs/seed)
  * `DbtSnapshotOperator`
    * Calls [`dbt snapshot`](https://docs.getdbt.com/docs/snapshot)
  * `DbtRunOperator`
    * Calls [`dbt run`](https://docs.getdbt.com/docs/run)
  * `DbtTestOperator`
    * Calls [`dbt test`](https://docs.getdbt.com/docs/test)
  * `DbtCleanOperator`
    * Calls [`dbt clean`](https://docs.getdbt.com/docs/clean)


  Each of the above operators accept the following arguments:

  * `env`
    * If set as a kwarg dict, passed the given environment variables as the arguments to the dbt task
  * `profiles_dir`
    * If set, passed as the `--profiles-dir` argument to the `dbt` command
  * `target`
    * If set, passed as the `--target` argument to the `dbt` command
  * `dir`
    * The directory to run the `dbt` command in
  * `full_refresh`
    * If set to `True`, passes `--full-refresh`
  * `vars`
    * If set, passed as the `--vars` argument to the `dbt` command. Should be set as a Python dictionary, as will be passed to the `dbt` command as YAML
  * `models`
    * If set, passed as the `--models` argument to the `dbt` command
  * `exclude`
    * If set, passed as the `--exclude` argument to the `dbt` command
  * `select`
    * If set, passed as the `--select` argument to the `dbt` command
  * `selector`
    * If set, passed as the `--selector` argument to the `dbt` command
  * `dbt_bin`
    * The `dbt` CLI. Defaults to `dbt`, so assumes it's on your `PATH`
  * `verbose`
    * The operator will log verbosely to the Airflow logs
  * `warn_error`
    * If set to `True`, passes `--warn-error` argument to `dbt` command and will treat warnings as errors

  Typically you will want to use the `DbtRunOperator`, followed by the `DbtTestOperator`, as shown earlier.

  You can also use the hook directly. Typically this can be used for when you need to combine the `dbt` command with another task in the same operators, for example running `dbt docs` and uploading the docs to somewhere they can be served from.



  To install from the repository:
  First it's recommended to create a virtual environment:
  ```bash
  python3 -m venv .venv

  source .venv/bin/activate
  ```

  Install using `pip`:
  ```bash
  pip install .
  ```



  To run tests locally, first create a virtual environment (see [Building Locally](https://github.com/gocardless/airflow-dbt#building-locally) section)

  Install dependencies:
  ```bash
  pip install . pytest
  ```

  Run the tests:
  ```bash
  pytest tests/
  ```


  This project uses [flake8](https://flake8.pycqa.org/en/latest/).

  To check your code, first create a virtual environment (see [Building Locally](https://github.com/gocardless/airflow-dbt#building-locally) section):
  ```bash
  pip install flake8
  flake8 airflow_dbt/ tests/ setup.py
  ```



  If you use dbt's package manager you should include all dependencies before deploying your dbt project.

  For Docker users, packages specified in `packages.yml` should be included as part your docker image by calling `dbt deps` in your `Dockerfile`.



  If you use MWAA, you just need to update the `requirements.txt` file and add `airflow-dbt` and `dbt` to it.

  Then you can have your dbt code inside a folder `{DBT_FOLDER}` in the dags folder on S3 and configure the dbt task like below:

  ```python
  dbt_run = DbtRunOperator(
    task_id='dbt_run',
    dbt_bin='/usr/local/airflow/.local/bin/dbt',
    profiles_dir='/usr/local/airflow/dags/{DBT_FOLDER}/',
    dir='/usr/local/airflow/dags/{DBT_FOLDER}/'
  )
  ```



  If you would like to run DBT using custom profile definition template with environment-specific variables, like for example profiles.yml using jinja:
  ```yaml
  <profile_name>:
    outputs:
      <source>:
        database: "{{ env_var('DBT_ENV_SECRET_DATABASE') }}"
        password: "{{ env_var('DBT_ENV_SECRET_PASSWORD') }}"
        schema: "{{ env_var('DBT_ENV_SECRET_SCHEMA') }}"
        threads: "{{ env_var('DBT_THREADS') }}"
        type: <type>
        user: "{{ env_var('USER_NAME') }}_{{ env_var('ENV_NAME') }}"
    target: <source>
  ```

  You can pass the environment variables via the `env` kwarg parameter:

  ```python
  import os
  ...

  dbt_run = DbtRunOperator(
    task_id='dbt_run',
    env={
      'DBT_ENV_SECRET_DATABASE': '<DATABASE>',
      'DBT_ENV_SECRET_PASSWORD': '<PASSWORD>',
      'DBT_ENV_SECRET_SCHEMA': '<SCHEMA>',
      'USER_NAME': '<USER_NAME>',
      'DBT_THREADS': os.getenv('<DBT_THREADS_ENV_VARIABLE_NAME>'),
      'ENV_NAME': os.getenv('ENV_NAME')
    }
  )
  ```



  * This is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
  * Bug reports and pull requests are welcome on GitHub at https://github.com/gocardless/airflow-dbt.

  GoCardless ♥ open source. If you do too, come [join us](https://gocardless.com/about/jobs).


pkgId: bf012d607486287308e2f93ac66adf2b24f638e6bd917d84cc5d0830a78a63ce
name: python-airflow-deploy-softwrd
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: A Flask application to handle postman webhooks for deploying and taking down repositories.
url: https://github.com/softwrdai/airflow_deploy_softwrd
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-deploy-softwrd-0.0.8-1.src.rpm
checksum_type: sha256
description:
  A Flask application to handle POSTMAN webhooks for deploying and taking down repositories using Docker Compose. This application is particularly designed for managing Airflow deployment of softwrd in house hosted repositories.


  - Deploy specified branches of a repository on push events.
  - Bring down specified branches of a repository.
  - Retrieve secrets from AWS Secrets Manager.
  - Automatically configure environment variables from secrets.


  - Python 3.9 or higher
  - Docker and Docker Compose
  - AWS credentials setup if using Secrets Manager



  You can install the package from PyPI:

  ```bash
  pip install airflow_deploy_softwrd
  ```




  Set up your AWS credentials using the following command:
  ```bash
  $Env:AWS_ACCESS_KEY_ID = "your-access-key-id"
  $Env:AWS_SECRET_ACCESS_KEY = "your-secret-access-key"
  ```
  you must have to set up your AWS credentials in your environment variables before running the application.



  To run the server, use the following command:

  ```bash
  airflow_deploy_softwrd /path/to/your/working/directory /path/to/config.json
  ```


  - `/path/to/your/working/directory`: The base directory where repositories will be cloned and operated.
  - `/path/to/config.json`: Path to the configuration file containing allowed branches.


  Create a JSON configuration file, e.g., `config.json`, with the following contents to specify allowed branches:
  NB. you can set SSH to true if you want to clone the repository using SSH.

  ```json
  {
    "allowed_branches": ["develop", "main", "Airflow-Changelog"],
    "SSH": false
  }
  ```





  Set up the following secrets in AWS Secrets Manager:
  - `airflow_deployment_env`: Secret containing environment variables for deploying Airflow.
  - `airflow_variables_env`: Secret containing Airflow variable configurations.


  Set up POSTMAN webhooks to point to the following endpoints of your running Flask application:

  - Deploying a branch:
    ```
    http://localhost:6969/payload
    ```

  - Bringing down a branch:
    ```
    http://localhost:6969/putdown
    ```




  The webhook for deploying a branch should contain information about the branch and repository in the body of the payload:

  ```json
  {
    "ref": "refs/heads/main",
    "repository": {
      "clone_url": "https://github.com/yourusername/yourrepo.git",
      "name": "yourrepo"
    },
    "head_commit": {
      "message": "Your commit message"
    }
  }
  ```


  The webhook for bringing down a branch should contain similar information:

  ```json
  {
    "ref": "refs/heads/main",
    "repository": {
      "clone_url": "https://github.com/yourusername/yourrepo.git",
      "name": "yourrepo"
    },
    "head_commit": {
      "message": "Your commit message"
    }
  }
  ```



  Maintainer: [Md Robiuddin](mailto:robiuddin@softwrd.ai)

  Project Link: [Repository URL](https://github.com/softwrdai/airflow_deploy_softwrd/)


pkgId: 730f62c5e7a4eee1810850e44b4b86b5904760a6252ec7075d905f653138d9b3
name: python-airflow-docker-compose
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/airflowdocker/airflow-docker-compose
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-docker-compose-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/airflowdocker/airflow-docker-compose.svg?style=svg)](https://circleci.com/gh/airflowdocker/airflow-docker-compose) [![codecov](https://codecov.io/gh/airflowdocker/airflow-docker-compose/branch/master/graph/badge.svg)](https://codecov.io/gh/airflowdocker/airflow-docker-compose)


  A reasonably light wrapper around `docker-compose` to make it simple to start a local
  airflow instance in docker.



  ```bash
  airflow-docker-compose --help
  airflow-docker-compose up
  ```




  Note, this library assumes the `docker-compose` utility is available in your path.

  In order to use this tool, you should have a local `dags` folder containing your dags.
  You should also have a `pyproject.toml` file which minimally looks like

  ```ini
  [tool.airflow-docker-compose]
  docker-network = 'network-name'
  ```

  In order to set airflow configuration, you can use the `airflow-environment-variables` key.
  This allows you to set any `airflow.cfg` variables like so:

  ```ini
  [tool.airflow-docker-compose]
  airflow-environment-variables = {
      AIRWFLOW_WORKER_COUNT = 4
      AIRFLOW__AIRFLOWDOCKER__FORCE_PULL = 'false'
  }


pkgId: 223dd794146894be01d6926c75f3a37437672bf4acf69cbd65b8e068cc0a97d3
name: python-airflow-exporter
arch: src
version: 1.5.3
epoch: 0
release: 1
summary: Airflow plugin to export dag and task based metrics to Prometheus.
url: https://github.com/epoch8/airflow-exporter
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-exporter-1.5.3-1.src.rpm
checksum_type: sha256
description:
  Exposes dag and task based metrics from Airflow to a Prometheus compatible endpoint.




  Current version is compatible with Airflow 2.0+


  Version v1.3.2 is compatible

  **Note: Airflow 1.10.14 with Python 3.8 users**

  You should install `importlib-metadata` package in order for plugin to be loaded. See [#85](https://github.com/epoch8/airflow-exporter/issues/85) for details.


  Version [v0.5.4](https://github.com/epoch8/airflow-exporter/releases/tag/v0.5.4) is compatible



  ```sh
  pip install airflow-exporter
  ```

  That's it. You're done.



  It is possible to add extra labels to DAG-related metrics by providing `labels` dict to DAG `params`.



  ```python
  dag = DAG(
      'dummy_dag',
      schedule_interval=timedelta(hours=5),
      default_args=default_args,
      catchup=False,
      params={
          'labels': {
              'env': 'test'
          }
      }
  )
  ```

  Label `env` with value `test` will be added to all metrics related to `dummy_dag`:

  `airflow_dag_status{dag_id="dummy_dag",env="test",owner="owner",status="running"} 12.0`



  Metrics will be available at

  ```
  http://<your_airflow_host_and_port>/admin/metrics/
  ```



  Labels:

  * `dag_id`
  * `task_id`
  * `owner`
  * `status`

  Value: number of tasks in a specific status.



  Labels:

  * `dag_id`
  * `owner`
  * `status`

  Value: number of dags in a specific status.



  Labels:

  * `dag_id`: unique identifier for a given DAG

  Value: duration in seconds of the longest DAG Run for given DAG. This metric
  is not available for DAGs that have already finished.



  Labels:

  * `dag_id`
  * `owner`
  * `status`

  Value: 0 or 1 depending on wherever the current state of each `dag_id` is `status`.



  Distributed under the BSD license. See [LICENSE](LICENSE) for more
  information.


pkgId: 34c6d88e27df81db21466cd1b61bf7d446ea6dadde43702b7b43980be29f829d
name: python-airflow-fernet-secrets
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: airflow filesystem secret backend using fernet
url: https://pypi.org/project/airflow-fernet-secrets/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-fernet-secrets-0.2.1-1.src.rpm
checksum_type: sha256
description:
  [![License: Apache-2.0](https://img.shields.io/badge/License-Apache_2.0-yellow.svg)](https://opensource.org/licenses/Apache-2.0)
  [![github action](https://github.com/phi-friday/airflow-fernet-secrets/actions/workflows/check.yaml/badge.svg?event=push)](#)
  [![PyPI version](https://badge.fury.io/py/airflow-fernet-secrets.svg)](https://badge.fury.io/py/airflow-fernet-secrets)
  [![python version](https://img.shields.io/pypi/pyversions/airflow-fernet-secrets.svg)](#)


  ```sh
  pip install airflow-fernet-secrets


  ```



  ```properties
  AIRFLOW__SECRETS__BACKEND=airflow.providers.fernet_secrets.secrets.secret_manager.FernetLocalSecretsBackend



  AIRFLOW__PROVIDERS_FERNET_SECRETS__SECRET_KEY=# some fernet key







  AIRFLOW__PROVIDERS_FERNET_SECRETS__BACKEND_FILE=# some sqlite file path







  ```

  ```python
  from __future__ import annotations

  from typing import TYPE_CHECKING

  from pendulum import datetime

  from airflow.decorators import dag, task
  from airflow.providers.fernet_secrets.operators.sync import DumpSecretsOperator

  if TYPE_CHECKING:
      from airflow_fernet_secrets.typings import SecretsParameter


  @dag(start_date=datetime(2024, 1, 1), catchup=False, schedule=None)
  def dump_connection():
      @task.load_fernet()
      def load_connection() -> SecretsParameter:
          return {"conn_ids": "some_conn_id"}

      dump = DumpSecretsOperator(task_id="dump", fernet_secrets_conn_ids="some_conn_id")
      load = load_connection()
      _ = dump >> load


  dump_connection()
  ```


  - [x] exceptions
  - [ ] mysql
  - [x] mssql(`pymssql`)
  - [ ] more tests

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024 Choi Min-yeong  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 8ee6bf250c220e388034f35ec5805b9f61f33708a293f9fd5c2ce9b8ecc6f778
name: python-airflow-google-ads-api-report-fetcher
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Library for running google-ads-api-report-fetcher in Apache Airflow.
url: https://github.com/google/ads-api-reports-fetcher/py/gaarf_airflow/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-google-ads-api-report-fetcher-0.0.7-1.src.rpm
checksum_type: sha256
description:
  If you want to use Apache Airflow to run any gaarf-based projects you can use
  `airflow-google-ads-api-report-fetcher` package.

  Install it with `pip install airflow-google-ads-api-report-fetcher` -
  it will make  `airflow_gaarf` library available.

  > Install the latest development version with `pip install -e git+https://github.com/google/ads-api-report-fetcher.git#egg=airflow-google-ads-api-report-fetcher\&subdirectory=py/airflow_gaarf`

  The library comes with two operators - `GaarfOperator` and `GaarfBqOperator` which can
  be used to simplify executing `google_ads_queries` and `bq_queries` respectively.




  Template pipeline expects two type of connections - go to *Admin - Connections*,
  add new connection (type *Generic*) and in *Extra* add the values specified below:

  * `google_ads_default`

  		{"google_ads_client":
  			{"developer_token": "",
  			"client_id": "",
  			"client_secret": "",
  			"refresh_token": "",
  			"login_customer_id": "",
  			"client_customer_id": "",
  			"use_proto_plus": "true"
  			}
  		}

  * `gcp_conn_id`

  	  {"cloud":
  			{"project_id": "your-project"}
  	  }




  Once the above connections were setup you may proceed to configuring DAG.
  `examples` folder contains several DAGs you might find useful:

  * `01_gaarf_console_reader_console_writer.py` - simple DAG which consist of a single `GaarfOperator` what fetches data from an inline query and outputs results to the console.
  * `02_gaarf_file_reader_csv_writer.py` - DAG that reads query from a file (can be local or remote storage) and save results to CSV.
  * `03_gaarf_read_solution_directory` - DAG that reads queries from a directory with queries and for reach query builds its own task.


pkgId: 9f5436955af1dc0236db3d65797b6355791382cddbd834a10bf0cab38acb8149
name: python-airflow-gpg-plugin
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Airflow plugin to work with GPG files.
url: https://github.com/tilakpatidar/fibber-csv
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-gpg-plugin-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Latest Version](https://img.shields.io/pypi/v/airflow-gpg-plugin.svg)](https://pypi.org/project/airflow-gpg-plugin/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/airflow-gpg-plugin.svg)](https://pypi.org/project/airflow-gpg-plugin/)

  Airflow plugin with hooks and operators to work with GPG encryption and decryption.



  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install foobar.

  ```bash
  pip install airflow-gpg-plugin
  ```



  Add an airflow connection from shell.

  `login` is the email address in the GPG key.

  `password` is the passphrase of the GPG key.

  ```shell
  airflow connections add 'gpg_default_conn' \
      --conn-type 'gpg' \
      --conn-login 'gpgexamplepassphrase@example.com' \
      --conn-password 'gpgexamplepassphrase' \
      --conn-host '' \
      --conn-port '' \
      --conn-extra '{"key_file": "tests/resources/gpgexamplepassphrase.asc"}'
  ```

  Using operators to encrypt and decrypt files.
  ```python
  import os
  from datetime import datetime

  from airflow import DAG
  from airflow_gpg_plugin.operators.gpg_decrypt_file_operator import GPGDecryptFileOperator
  from airflow_gpg_plugin.operators.gpg_encrypt_file_operator import GPGEncryptFileOperator
  gpg_conn_id = "gpg_default_conn"

  dag = DAG(dag_id="gpg_example",
            start_date=datetime(2021, 1, 1),
            schedule_interval=None
            )

  encrypt = GPGEncryptFileOperator(
      task_id="gpg_encrypt",
      dag=dag,
      conn_id=gpg_conn_id,
      input_file_path=os.curdir + "/README.md",
      output_file_path=os.curdir + "/README.md.gpg"
  )
  decrypt = GPGDecryptFileOperator(
      task_id="gpg_decrypt",
      dag=dag,
      conn_id=gpg_conn_id,
      input_file_path=os.curdir + "/README.md.gpg",
      output_file_path=os.curdir + "/README.md.txt"
  )

  encrypt >> decrypt


  ```


  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

  Please make sure to update tests as appropriate.


  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: e6203b6ce3701e4160cf09fca5b3a761ba0bcdc007761fec86be206e1e41af6c
name: python-airflow-ha
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: High Availability (HA) DAG Utility
url: https://github.com/airflow-laminar/airflow-ha
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-ha-0.1.2-1.src.rpm
checksum_type: sha256
description:
  High Availability (HA) DAG Utility

  [![Build Status](https://github.com/airflow-laminar/airflow-ha/actions/workflows/build.yml/badge.svg?branch=main&event=push)](https://github.com/airflow-laminar/airflow-ha/actions/workflows/build.yml)
  [![codecov](https://codecov.io/gh/airflow-laminar/airflow-ha/branch/main/graph/badge.svg)](https://codecov.io/gh/airflow-laminar/airflow-ha)
  [![License](https://img.shields.io/github/license/airflow-laminar/airflow-ha)](https://github.com/airflow-laminar/airflow-ha)
  [![PyPI](https://img.shields.io/pypi/v/airflow-ha.svg)](https://pypi.python.org/pypi/airflow-ha)



  This library provides an operator called `HighAvailabilityOperator`, which inherits from `PythonSensor` and runs a user-provided `python_callable`.
  The return value can trigger the following actions:

  | Return              | Result                                       | Current DAGrun End State |
  | :-----              | :-----                                       | :----------------------- |
  | `(PASS, RETRIGGER)` | Retrigger the same DAG to run again          | `pass`                   |
  | `(PASS, STOP)`      | Finish the DAG, until its next scheduled run | `pass`                   |
  | `(FAIL, RETRIGGER)` | Retrigger the same DAG to run again          | `fail`                   |
  | `(FAIL, STOP)`      | Finish the DAG, until its next scheduled run | `fail`                   |
  | `(*, CONTINUE)`     | Continue to run the Sensor                   | N/A                      |

  Note: if the sensor times out, the behavior matches `(Result.PASS, Action.RETRIGGER)`.



  Consider the following DAG:

  ```python
  with DAG(
      dag_id="test-high-availability",
      description="Test HA Operator",
      schedule=timedelta(days=1),
      start_date=datetime(2024, 1, 1),
      catchup=False,
  ):
      ha = HighAvailabilityOperator(
          task_id="ha",
          timeout=30,
          poke_interval=5,
          python_callable=lambda **kwargs: choice(
              (
                  (Result.PASS, Action.CONTINUE),
                  (Result.PASS, Action.RETRIGGER),
                  (Result.PASS, Action.STOP),
                  (Result.FAIL, Action.CONTINUE),
                  (Result.FAIL, Action.RETRIGGER),
                  (Result.FAIL, Action.STOP),
              )
          ),
      )

      pre = PythonOperator(task_id="pre", python_callable=lambda **kwargs: "test")
      pre >> ha

      retrigger_fail = PythonOperator(task_id="retrigger_fail", python_callable=lambda **kwargs: "test")
      ha.retrigger_fail >> retrigger_fail

      stop_fail = PythonOperator(task_id="stop_fail", python_callable=lambda **kwargs: "test")
      ha.stop_fail >> stop_fail

      retrigger_pass = PythonOperator(task_id="retrigger_pass", python_callable=lambda **kwargs: "test")
      ha.retrigger_pass >> retrigger_pass

      stop_pass = PythonOperator(task_id="stop_pass", python_callable=lambda **kwargs: "test")
      ha.stop_pass >> stop_pass
  ```

  This produces a DAG with the following topology:

  <img src="https://raw.githubusercontent.com/airflow-laminar/airflow-ha/main/docs/src/top.png" />

  This DAG exhibits cool behavior.
  If the check returns `CONTINUE`, the DAG will continue to run the sensor.
  If the check returns `RETRIGGER` or the interval elapses, the DAG will re-trigger itself and finish.
  If the check returns `STOP`, the DAG will finish and not retrigger itself.
  If the check returns `PASS`, the current DAG run will end in a successful state.
  If the check returns `FAIL`, the current DAG run will end in a failed state.

  This allows the one to build "always-on" DAGs without having individual long blocking tasks.

  This library is used to build [airflow-supervisor](https://github.com/airflow-laminar/airflow-supervisor), which uses [supervisor](http://supervisord.org) as a process-monitor while checking and restarting jobs via `airflow-ha`.



  You can also use this library to build recursive DAGs - or "Cyclic DAGs", despite the oxymoronic name.

  The following code makes a DAG that triggers itself with some decrementing counter, starting with value 3:

  ```python

  with DAG(
      dag_id="test-ha-counter",
      description="Test HA Countdown",
      schedule=timedelta(days=1),
      start_date=datetime(2024, 1, 1),
      catchup=False,
  ):

      def _get_count(**kwargs):
          
          return kwargs['dag_run'].conf.get('counter', 3) - 1

      get_count = PythonOperator(task_id="get-count", python_callable=_get_count)

      def _keep_counting(**kwargs):
          count = kwargs["task_instance"].xcom_pull(key="return_value", task_ids="get-count")
          return (Result.PASS, Action.RETRIGGER) if count > 0 else (Result.PASS, Action.STOP) if count == 0 else (Result.FAIL, Action.STOP)

      keep_counting = HighAvailabilityOperator(
          task_id="ha",
          timeout=30,
          poke_interval=5,
          python_callable=_keep_counting,
          pass_trigger_kwargs={"conf": '''{"counter": {{ ti.xcom_pull(key="return_value", task_ids="get-count") }}}'''},
      )

      get_count >> keep_counting
  ```
  <img src="https://raw.githubusercontent.com/airflow-laminar/airflow-ha/main/docs/src/rec.png" />



  This software is licensed under the Apache 2.0 license. See the [LICENSE](LICENSE) file for details.


pkgId: 6f35fb7633c0a86c49c51254ab9e9ffc7edd654f3f24a8425a75bfa93dab669c
name: python-airflow-hop-plugin
arch: src
version: 0.1.0b6
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/damavis/airflow-hop-plugin
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airflow-hop-plugin-0.1.0b6-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://api.travis-ci.com/damavis/airflow-hop-plugin.svg?branch=main)](https://app.travis-ci.com/damavis/airflow-hop-plugin)
  [![codecov](https://codecov.io/gh/damavis/airflow-hop-plugin/branch/main/graph/badge.svg?token=IRE2T3NEOD)](https://codecov.io/gh/damavis/airflow-hop-plugin)
  [![PyPI](https://img.shields.io/pypi/v/airflow-hop-plugin)](https://pypi.org/project/airflow-hop-plugin/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/airflow-hop-plugin)](https://pypi.org/project/airflow-hop-plugin/)



  This is an Apache Hop plugin for Apache Airflow in order to orchestrate Apache Hop pipelines and workflows from Airflow.



  Before setting up the plugin you must have completely set up your Hop environment:

  - Configured Hop Server
  - Configured remote pipeline configuration
  - Configured remote workflow configuration

  To do so, go to the metadata window in Hop UI by pressing Ctrl+Shift+M or click the ![icono](images/Metadata_icon.png) icon.

  ![Hop Server](images/Hop_server.png)

  Double click `Hop server` to create a new configuration.

  ![Remote pipeline Config](images/Pipeline_Run_config.png)

  Double click `Pipeline Run Configuration` to create a new configuration.

  ![Remote workflow config](images/Workflow_Run_config.png)

  Double click `Workflow Run Configuration` to create a new configuration.



  The following content will be a "how to set up the plugin" guide plus some requirements and
  restraints when it comes to its usage.



  For the correct configuration of this plugin a file containing all Hop's metadata must be created
  inside each project directory. This can be done by exporting it from Hop UI.

  Please note that this process must be repeated each time the metadata of a project is modified.

  ![Metadata option](images/Export_metadata.png)



  The first step in order to get this plugin working is to install the package using the following
  command:

  ```
  pip install airflow-hop-plugin
  ```



  Due to some technical limitations it's really important for the Hop home directory to have the
  following structure.

  ```
  hop # This is the hop home directory
  ├── ...
  ├── config
  │   ├── hop-config.json
  │   ├── example_environment.json # This is where you should save your environment files
  │   ├── metadata
  │   │   └── ...
  │   └── projects
  │       ├── ...
  │       └── example_project # This is how your project's directory should look
  │           ├── metadata.json
  │           ├── metadata
  │           │   └── ...
  │           ├── example_directory
  │           │   └── example_workflow.hwl
  │           └── example_pipeline.hpl
  ├── ...
  ```

  Moreover, please remember to save all projects inside the "projects" directory and set a path
  relative to the hop home directory when configuring them like shown in the following picture:

  ![Here goes an image](images/project_properties.png)


  To correctly use the operators you must create a new
  [Airflow connection](https://airflow.apache.org/docs/apache-airflow/stable/howto/connection.html).
  There are multiple ways to do so and whichever you want can be used, but it should have these
  values for the following attributes:

  - Connection ID: 'hop_default'
  - Connection Type: 'http'
  - Login: apache_hop_username
  - Password: apache_hop_password
  - Host: apache_hop_server
  - Port: apache_hop_port
  - Extra: "hop_home": "/path/to/hop-home/"

   Example of a new Airflow connection using Airflow's CLI:

  ```
  airflow connections add 'hop_default' \
      --conn-json '{
          "conn_type": "http",
          "login": "cluster",
          "password": "cluster",
          "host": "0.0.0.0",
          "port": 8080,
          "schema": "",
          "extra": {
              "hop_home": "/home/user/hop"
          }
      }'
  ```



  Here's an example of a DAG:

  ```python
  from airflow_hop.operators import HopPipelineOperator
  from airflow_hop.operators import HopWorkflowOperator



  with DAG('sample_dag', start_date=datetime(2022,7,26),
          schedule_interval='@daily', catchup=False) as dag:

      
      first_pipe = HopPipelineOperator(
          task_id='first_pipe',
          pipeline='pipelines/first_pipeline.hpl',
          pipe_config='remote hop server',
          project_name='default',
          log_level='Basic')

      
      second_pipe = HopPipelineOperator(
          task_id='second_pipe',
          pipeline='pipelines/second_pipeline.hpl',
          pipe_config='remote hop server',
          project_name='default',
          log_level='Basic',
          params={'DATE':'{{ ds }}'}) # Date in yyyy-mm-dd format

      
      work_test = HopWorkflowOperator(
          task_id='work_test',
          workflow='workflows/workflow_example.hwf',
          project_name='default',
          log_level='Basic',
          params={'DATE':'{{ ds }}'}) # Date in yyyy-mm-dd format

      first_pipe >> second_pipe >> work_test
  ```

  It's important to point out that both the workflow and pipeline parameters within their respective
  operators must be a relative path parting from the project's directory.





  Requeriments:

  - [docker](https://docs.docker.com/engine/install/)
  - [docker-compose](https://docs.docker.com/compose/install/)

  If you want to use Docker to create the server you can use the following docker-compose
  configuration as a template:

  ```yaml
  services:
    apache-hop:
      image: apache/hop:latest
      ports:
        - 8080:8080
      volumes:
        - hop_path:/home/hop
      environment:
        HOP_SERVER_USER: cluster
        HOP_SERVER_PASS: cluster
        HOP_SERVER_PORT: 8080
        HOP_SERVER_HOSTNAME: 0.0.0.0
  ```

  Once done, the Hop server can be started using docker compose.



  ```
  Copyright 2022 Aneior Studio, SL

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  ```


