# packages

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




  * Python (~=3.9)
  * Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/instatus)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_instatus/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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


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


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-instatus build
  ```

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-instatus:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-instatus:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-instatus:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-instatus:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```


  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-instatus test
  ```


  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.


  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.


  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-instatus test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/instatus.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





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

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



  Then run any of the connector commands as follows:

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




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

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



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





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

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



  Then run any of the connector commands as follows:

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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/iterable)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_iterable/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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



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

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-iterable:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-iterable:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-iterable:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-iterable:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-iterable test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-iterable test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/iterable.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





  * Python (`^3.9`)
  * Poetry (`^1.7`) - installation instructions [here](https://python-poetry.org/docs/#installation)





  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```




  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/jina-ai-reader)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `spec` inside `source_jina_ai_reader/mainfest.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `integration_tests/sample_config.json` for a sample config file.




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



  To run tests locally, from the connector directory run:

  ```
  poetry run pytest tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-jina-ai-reader build
  ```

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




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-jina-ai-reader:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-jina-ai-reader:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-jina-ai-reader:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-jina-ai-reader:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-jina-ai-reader test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-jina-ai-reader test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/jina-ai-reader.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/jira)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_jira/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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



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

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-jira:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-jira:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-jira:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-jira:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-jira test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-jira test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/jira.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/klaviyo)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_klaviyo/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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



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

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-klaviyo:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-klaviyo:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-klaviyo:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-klaviyo:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-klaviyo test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-klaviyo test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/klaviyo.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/kyriba)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_kyriba/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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



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

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-kyriba:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-kyriba:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-kyriba:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-kyriba:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-kyriba test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-kyriba test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/kyriba.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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




  * Python (~=3.9)
  * Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/kyve)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_kyve/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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


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


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-kyve build
  ```

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-kyve:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-kyve:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-kyve:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-kyve:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```


  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-kyve test
  ```


  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.


  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.


  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-kyve test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/kyve.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





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

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




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





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

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

  **Via `docker build`:**

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



  Then run any of the connector commands as follows:

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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/linkedin-ads)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_linkedin_ads/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `integration_tests/sample_config.json` for a sample config file.



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



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

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

  ```bash
  airbyte-ci connectors --name=source-linkedin-ads build
  ```

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-linkedin-ads:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-linkedin-ads:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-linkedin-ads:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-linkedin-ads:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-linkedin-ads test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-linkedin-ads test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/linkedin-ads.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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




  * Python (~=3.9)
  * Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)




  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```




  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/linkedin-pages)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `src/source_linkedin_pages/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.




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


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


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-linkedin-pages build
  ```

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-linkedin-pages:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-linkedin-pages:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-linkedin-pages:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-linkedin-pages:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```


  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-linkedin-pages test
  ```


  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.


  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.


  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-linkedin-pages test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/linkedin-pages.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/linnworks)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_linnworks/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `integration_tests/sample_config.json` for a sample config file.



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



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

  ```bash
  poetry run pytest unit_tests
  ```





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

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

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



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

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

  ```python
  from __future__ import annotations

  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      
      
      from dagger import Container


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

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



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

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

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

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

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




  ```

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

  2. Build your image:

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

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



  Then run any of the connector commands as follows:

  ```bash
  docker run --rm airbyte/source-linnworks:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-linnworks:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-linnworks:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-linnworks:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-linnworks test
  ```



  Customize `acceptance-test-config.yml` file to configure tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.

  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-linnworks test`
  2. Bump the connector version in `metadata.yaml`: increment the `dockerImageTag` value. Please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors).
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make the connector documentation and its changelog is up to date (`docs/integrations/sources/linnworks.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.


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





  * Python (`^3.9`)
  * Poetry (`^1.7`) - installation instructions [here](https://python-poetry.org/docs/#installation)





  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```




  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/looker)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `src/source_looker/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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



  To run tests locally, from the connector directory run:

  ```
  poetry run pytest tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-looker build
  ```

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




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-looker:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-looker:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-looker:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-looker:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-looker test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-looker test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/looker.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/mailchimp)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_mailchimp/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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



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

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-mailchimp:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-mailchimp:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-mailchimp:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-mailchimp:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-mailchimp test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-mailchimp test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/mailchimp.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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




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

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



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





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

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



  Then run any of the connector commands as follows:

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




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

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



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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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





  - Python (~=3.7)
  - 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/metabase)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_metabase/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/config.json` for a sample config file.



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

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



  Then run any of the connector commands as follows:

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




  * Python (~=3.9)
  * Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/microsoft-dataverse)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_microsoft_dataverse/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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


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


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-microsoft-dataverse build
  ```

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-microsoft-dataverse:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-microsoft-dataverse:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-microsoft-dataverse:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-microsoft-dataverse:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```


  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-microsoft-dataverse test
  ```


  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.


  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.


  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-microsoft-dataverse test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/microsoft-dataverse.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: 1dc00044d4a0a69123e9b45599f2b55b0a363e185b082e67144b62baa6a28b5c
name: python-airbyte-source-microsoft-onedrive
arch: src
version: 0.2.22
epoch: 0
release: 1
summary: Source implementation for Microsoft OneDrive.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-microsoft-onedrive-0.2.22-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Microsoft OneDrive source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/microsoft-onedrive).





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/microsoft-onedrive)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_microsoft_onedrive/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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



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

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

  ```bash
  airbyte-ci connectors --name=source-microsoft-onedrive build
  ```

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-microsoft-onedrive:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-microsoft-onedrive:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-microsoft-onedrive:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-microsoft-onedrive:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-microsoft-onedrive test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-microsoft-onedrive test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/microsoft-onedrive.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/microsoft-sharepoint)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_microsoft_sharepoint/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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



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

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

  ```bash
  airbyte-ci connectors --name=source-microsoft-sharepoint build
  ```

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-microsoft-sharepoint:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-microsoft-sharepoint:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-microsoft-sharepoint:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-microsoft-sharepoint:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-microsoft-sharepoint test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-microsoft-sharepoint test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/microsoft-sharepoint.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: d0bff2e3fa959da51692b6efa2c26bf1b5c7de57ba1a180991f658c1a72cc065
name: python-airbyte-source-microsoft-teams
arch: src
version: 1.1.11
epoch: 0
release: 1
summary: Source implementation for microsoft-teams.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-microsoft-teams-1.1.11-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Microsoft Teams configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/microsoft-teams).





  - Python (`^3.9`)
  - Poetry (`^1.7`) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/microsoft-teams)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `src/source_microsoft_teams/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-microsoft-teams:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-microsoft-teams:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-microsoft-teams:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-microsoft-teams:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-microsoft-teams test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-microsoft-teams test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/microsoft-teams.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: 39499d3850dd86121afe00de51d5095137ab9a25c87a2bbcd29ebe4b38c46740
name: python-airbyte-source-mixpanel
arch: src
version: 3.4.8
epoch: 0
release: 1
summary: Source implementation for Mixpanel.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-mixpanel-3.4.8-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Mixpanel source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/mixpanel).





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/mixpanel)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_mixpanel/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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



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

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-mixpanel:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-mixpanel:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-mixpanel:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-mixpanel:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-mixpanel test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-mixpanel test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/mixpanel.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/monday)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_monday/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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



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

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-monday:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-monday:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-monday:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-monday:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-monday test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-monday test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/monday.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





  - 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/my-hours)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `spec` inside `manifest/yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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

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



  Then run any of the connector commands as follows:

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




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

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



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




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

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



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

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




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





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

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



  Then run any of the connector commands as follows:

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





  - Python (`^3.10`)
  - 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/northpass-lms)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `src/source_northpass_lms/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-northpass-lms spec
  poetry run source-northpass-lms check --config secrets/config.json
  poetry run source-northpass-lms discover --config secrets/config.json
  poetry run source-northpass-lms read --config secrets/config.json --catalog sample_files/configured_catalog.json
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

  ```bash
  airbyte-ci connectors --name=source-northpass-lms build
  ```

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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





  * Python (`^3.9`)
  * Poetry (`^1.7`) - installation instructions [here](https://python-poetry.org/docs/#installation)





  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```




  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/okta)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `src/source_okta/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/config.json` for a sample config file.




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



  To run tests locally, from the connector directory run:

  ```
  poetry run pytest tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-okta build
  ```

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




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-okta:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-okta:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-okta:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-okta:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-okta test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-okta test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/okta.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





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



  To run 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-omnisend build
  ```

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




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





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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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




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

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



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




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

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



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





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





  From this connector directory, create a virtual environment:

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

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

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

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

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



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/outbrain-amplify)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_outbrain_amplify/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `integration_tests/sample_config.json` for a sample config file.

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



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






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

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


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

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

  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      
      
      from dagger import Container


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

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


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

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

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

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




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

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

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


  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-outbrain-amplify:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-outbrain-amplify:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-outbrain-amplify:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-outbrain-amplify:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-outbrain-amplify test
  ```



  Customize `acceptance-test-config.yml` file to configure tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should go in `setup.py`, NOT `requirements.txt`. The requirements file is only used to connect internal Airbyte dependencies in the monorepo for local development.
  We split dependencies between two groups, dependencies that are:

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



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-outbrain-amplify test`
  2. Bump the connector version in `metadata.yaml`: increment the `dockerImageTag` value. Please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors).
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make the connector documentation and its changelog is up to date (`docs/integrations/sources/outbrain-amplify.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.


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





  * Python (`^3.9`)
  * Poetry (`^1.7`) - installation instructions [here](https://python-poetry.org/docs/#installation)





  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```




  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/outreach)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `spec` inside `manifest.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `integration_tests/sample_config.json` for a sample config file.





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



  To run tests locally, from the connector directory run:

  ```
  poetry run pytest tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-outreach build
  ```

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





  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-outreach:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-outreach:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-outreach:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-outreach:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```





  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-outreach test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.

  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-outreach test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/outreach.md`).
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/outreach.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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




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

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



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




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

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



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




  * Python (~=3.9)
  * Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/partnerstack)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_partnerstack/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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


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


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-partnerstack build
  ```

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-partnerstack:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-partnerstack:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-partnerstack:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-partnerstack:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```


  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-partnerstack test
  ```


  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.


  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.


  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-partnerstack test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/partnerstack.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)
  - Paypal Client ID and Client Secret
  - If you are going to use the data generator scripts you need to setup yourPaypal Sandbox and a Buyer user in your sandbox, to simulate the data. YOu cna get that information in the [Apps & Credentials page](https://developer.paypal.com/dashboard/applications/live).
    - Buyer Username
    - Buyer Password
    - Payer ID (Account ID)



  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/paypal-transaction)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_paypal_transaction/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.

  - You must have created your credentials under the `secrets/` folder
  - For the read command, you can create separate catalogs to test the streams individually. All catalogs are under the folder `integration_tests`. Select the one you want to test with the read command.



  ```
  poetry run source-paypal-transaction spec
  poetry run source-paypal-transaction check --config secrets/config.json
  poetry run source-paypal-transaction discover --config secrets/config.json

  poetry run source-paypal-transaction read --config secrets/config.json --catalog integration_tests/configured_catalog_list_payments.json --debug
  ```



  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:



  From this connector directory, run:

  ```bash
  poetry install --with 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
  ```

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



  Then run any of the connector commands as follows:

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

  If you are testing locally, you can use your local credentials (config.json file) by using `--use-local-secrets`

  ```bash
  airbyte-ci connectors --name source-paypal-transaction --use-local-secrets 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.



  To run unit tests locally, form the root `source_paypal_transaction` directory run:

  ```bash
  python -m pytest unit_test
  ```



  If you have a [Paypal Sandbox](https://developer.paypal.com/tools/sandbox/accounts/) you will be able to use some APIs to create new data and test how data is being created in your destinaiton and choose the best syn strategy that suits better your use case.
  Some endpoints will require special permissions on the sandbox to update and change some values.

  In the `bin` folder you will find several data generator scripts:

  - **disputes_generator.py:**

    - Update dispute: Uses the _PATCH_ method of the `https://api-m.paypal.com/v1/customer/disputes/{dispute_id}` endpoint. You need the ID and create a payload to pass it as an argument. See more information [here](https://developer.paypal.com/docs/api/customer-disputes/v1/#disputes_patch).

    ```bash
    python disputes_generator.py update DISPUTE_ID ''[{"op": "replace", "path": "/reason", "value": "The new reason"}]'
    ```

    - Update Evidence status: Uses the _POST_ method of the `https://api-m.paypal.com/v1/customer/disputes/{dispute_id}/require-evidence` endpoint. You need the ID and select an option to pass it as an argument. See more information [here](https://developer.paypal.com/docs/api/customer-disputes/v1/#disputes_require-evidence)

    ```bash
    python update_dispute.py require-evidence DISPUTE_ID SELLER_EVIDENCE
    ```

  - **invoices.py:**

    - Create draft invoice: Uses the _POST_ method of the `https://api-m.sandbox.paypal.com/v2/invoicing/invoices` endpoint. It will automatically generate an invoice (no need to pass any parameters). See more information [here](https://developer.paypal.com/docs/api/invoicing/v2/#invoices_create).

    ```bash
    python invoices.py create_draft
    ```

    - Send a Draft Invoice: Uses the _POST_ method of the `https://api-m.sandbox.paypal.com/v2/invoicing/invoices/{invoice_id}/send` endpoint. You need the Invoice ID, a subject and a note (just to have something to update) and an email as an argument. See more information [here](https://developer.paypal.com/docs/api/invoicing/v2/#invoices_send)

    ```bash
    python invoices.py send_draft --invoice_id "INV2-XXXX-XXXX-XXXX-XXXX" --subject "Your Invoice Subject" --note "Your custom note" --additional_recipients example@email.com
    ```

  - **payments_generator.py:**

    - Partially update payment: Uses the _PATCH_ method of the `https://api-m.paypal.com/v1/payments/payment/{payment_id}` endpoint. You need the payment ID and a payload with new values. (no need to pass any parameters). See more information [here](https://developer.paypal.com/docs/api/invoicing/v2/#invoices_create).

    ```bash
     python script_name.py update PAYMENT_ID '[{"op": "replace", "path": "/transactions/0/amount", "value": {"total": "50.00", "currency": "USD"}}]'
    ```

  - **paypal_transaction_generator.py:**
    Make sure you have the `buyer_username`, `buyer_password` and `payer_id` in your config file. You can get the sample configuratin in the `sample_config.json`.

    - Generate transactions: This uses Selenium, so you will be prompted to your account to simulate the complete transaction flow. You can add a number at the end of the command to do more than one transaction. By default the script runs 3 transactions.

    **NOTE: Be midnfu of the number of transactions, as it will be interacting with your machine, and you may not be able to use it while creating the transactions**

    ```bash
     python paypal_transaction_generator.py [NUMBER_OF_DESIRED_TRANSACTIONS]
    ```

  - **product_catalog.py:**

    - Create a product: Uses the _POST_ method of the `https://api-m.sandbox.paypal.com/v1/catalogs/products` endpoint. You need to add the description and the category in the command line. For the proper category see more information [here](https://developer.paypal.com/docs/api/catalog-products/v1/#products_create).

    ```bash
    python product_catalog.py --action create --description "YOUR DESCRIPTION" --category PAYPAL_CATEGORY
    ```

    - Update a product: Uses the _PATCH_ method of the `https://developer.paypal.com/docs/api/catalog-products/v1/#products_patch` endpoint. You need the product ID, a description and the Category as an argument. See more information [here](https://developer.paypal.com/docs/api/catalog-products/v1/#products_patch)

    ```bash
    python product_catalog.py --action update --product_id PRODUCT_ID --update_payload '[{"op": "replace", "path": "/description", "value": "My Update. Does it changes it?"}]'
    ```



  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

  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-paypal-transaction 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/paypal-transaction.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: 51e1cfae9c9a108c19b95db4b3af8a511ebfe5d61b8938dc2fca885698f1a8c8
name: python-airbyte-source-paystack
arch: src
version: 1.0.11
epoch: 0
release: 1
summary: Source implementation for paystack.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-paystack-1.0.11-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Paystack configuration based source connector.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/paystack).





  * 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/paystack)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `spec` inside `source_paystack/mainfest.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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

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




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





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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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

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



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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/pinterest)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_pinterest/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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



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

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-pinterest:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-pinterest:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-pinterest:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-pinterest:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-pinterest test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-pinterest test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/pinterest.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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




  * Python (~=3.9)
  * Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/pipedrive)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_pipedrive/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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


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


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-pipedrive build
  ```

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-pipedrive:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-pipedrive:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-pipedrive:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-pipedrive:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```


  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-pipedrive test
  ```


  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.


  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.


  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-pipedrive test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/pipedrive.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





  * 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/pivotal-tracker)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `spec` inside `manifest.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `integration_tests/sample_config.json` for a sample config file.





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

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




  Then run any of the connector commands as follows:

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




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

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



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





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

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




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





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

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



  Then run any of the connector commands as follows:

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





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

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




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

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



  Then run any of the connector commands as follows:

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





  * Python (`^3.9`)
  * Poetry (`^1.7`) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.io/integrations/sources/posthog)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_posthog/spec.json` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.

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



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



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-posthog build
  ```

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-posthog:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-posthog:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-posthog:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/sample_files:/sample_files airbyte/source-posthog:dev read --config /secrets/config.json --catalog /sample_files/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-posthog test
  ```



  Customize `acceptance-test-config.yml` file to configure tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should go in `setup.py`, NOT `requirements.txt`. The requirements file is only used to connect internal Airbyte dependencies in the monorepo for local development.
  We split dependencies between two groups, dependencies that are:

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



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-posthog test`
  2. Bump the connector version in `metadata.yaml`: increment the `dockerImageTag` value. Please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors).
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make the connector documentation and its changelog is up to date (`docs/integrations/sources/posthog.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.


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





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

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



  Then run any of the connector commands as follows:

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




  * Python (~=3.9)
  * Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/public-apis)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_public_apis/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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


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


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-public-apis build
  ```

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-public-apis:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-public-apis:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-public-apis:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-public-apis:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```


  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-public-apis test
  ```


  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.


  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.


  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-public-apis test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/public-apis.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





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

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



  Then run any of the connector commands as follows:

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




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

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



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




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

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



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





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

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


  Then run any of the connector commands as follows:

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




  * Python (~=3.9)
  * Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/railz)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_railz/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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


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


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-railz build
  ```

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-railz:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-railz:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-railz:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-railz:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```


  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-railz test
  ```


  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.


  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.


  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-railz test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/railz.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


pkgId: 939afd17fd923ba262b282434cbd84d38c22b28e6f8a1a762a51cdc7231bdb0a
name: python-airbyte-source-rd-station-marketing
arch: src
version: 0.2.8
epoch: 0
release: 1
summary: Source implementation for RD Station Marketing.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-rd-station-marketing-0.2.8-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Rd-Station-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/rd-station-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/rd-station-marketing)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_rd_station_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-rd-station-marketing spec
  poetry run source-rd-station-marketing check --config secrets/config.json
  poetry run source-rd-station-marketing discover --config secrets/config.json
  poetry run source-rd-station-marketing read --config secrets/config.json --catalog integration_tests/configured_catalog.json
  ```


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


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-rd-station-marketing build
  ```

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



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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/recharge)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_recharge/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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



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

  ```
  poetry run pytest unit_tests
  ```



  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:

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

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



  Then run any of the connector commands as follows:

  ```
  docker run --rm airbyte/source-recharge:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-recharge:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-recharge:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-recharge:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```



  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):

  ```bash
  airbyte-ci connectors --name=source-recharge test
  ```



  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.



  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:

  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.



  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?

  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-recharge test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
     - bump the `dockerImageTag` value in in `metadata.yaml`
     - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/recharge.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





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

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



  Then run any of the connector commands as follows:

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




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

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



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





  - Python (~=3.9)
  - Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:

  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.io/integrations/sources/recurly)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_recurly/spec.json` file.
  Note that the `secrets` directory is gitignored by default, so there is no danger of accidentally checking in sensitive information.
  See `integration_tests/sample_config.json` for a sample config file.

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



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



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

  ```bash
  poetry run pytest unit_tests
  ```



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

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



  Then run any of the connector commands as follows:

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



  Customize the `acceptance-test-config.yml` file to configure acceptance tests. See our [Connector Acceptance Tests reference](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires you 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 the `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-recurly test`
  2. Bump the connector version listed as `dockerImageTag` in `metadata.yaml`. 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/recurly.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: 4ef7cc4ce8494bb4337514a5b79dc49e5eed089714f0f2f38bfdbf89c63084f9
name: python-airbyte-source-reply-io
arch: src
version: 0.1.15
epoch: 0
release: 1
summary: Source implementation for reply-io.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-reply-io-0.1.15-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Reply-Io source connector, written in Python.
  For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.com/integrations/sources/reply-io).





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

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




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





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

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



  Then run any of the connector commands as follows:

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




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

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



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




  * Python (~=3.9)
  * Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)



  From this connector directory, run:
  ```bash
  poetry install --with dev
  ```



  **If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.com/integrations/sources/rki-covid)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_rki_covid/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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


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


  1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md)
  2. Run the following command to build the docker image:
  ```bash
  airbyte-ci connectors --name=source-rki-covid build
  ```

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-rki-covid:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-rki-covid:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-rki-covid:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-rki-covid:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
  ```


  You can run our full test suite locally using [`airbyte-ci`](https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/pipelines/README.md):
  ```bash
  airbyte-ci connectors --name=source-rki-covid test
  ```


  Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
  If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.


  All of your dependencies should be managed via Poetry.
  To add a new dependency, run:
  ```bash
  poetry add <package-name>
  ```

  Please commit the changes to `pyproject.toml` and `poetry.lock` files.


  You've checked out the repo, implemented a million dollar feature, and you're ready to share your changes with the world. Now what?
  1. Make sure your changes are passing our test suite: `airbyte-ci connectors --name=source-rki-covid test`
  2. Bump the connector version (please follow [semantic versioning for connectors](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#semantic-versioning-for-connectors)):
      - bump the `dockerImageTag` value in in `metadata.yaml`
      - bump the `version` value in `pyproject.toml`
  3. Make sure the `metadata.yaml` content is up to date.
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/rki-covid.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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




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

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



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


