# packages

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




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

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-appfollow:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-appfollow:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-appfollow:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-appfollow: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-appfollow 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-appfollow 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/appfollow.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: 8eb1a4bc18072bdddc03795b7aad1320af3ac86819a78a373ddec33da3831463
name: python-airbyte-source-apple-search-ads
arch: src
version: 0.1.20
epoch: 0
release: 1
summary: Source implementation for Apple Search Ads.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-apple-search-ads-0.1.20-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Apple-Search-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/apple-search-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/apple-search-ads)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_apple_search_ads/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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


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


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

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



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




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



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



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



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


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


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

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



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


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


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


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

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


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


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





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





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




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





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



  To run tests locally, from the connector directory run:

  ```
  poetry run pytest tests
  ```



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

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




  Then run any of the connector commands as follows:

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



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

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



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



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

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



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

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


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





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

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



  Then run any of the connector commands as follows:

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





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

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





  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-aws-cloudtrail:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-aws-cloudtrail:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-aws-cloudtrail:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-aws-cloudtrail: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-aws-cloudtrail 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-aws-cloudtrail 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/aws-cloudtrail.md`).
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/aws-cloudtrail.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





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



  Tenant id should be provided by user, reason:
  https://learn.microsoft.com/en-us/answers/questions/1531138/which-tenant-id-do-i-have-to-use-to-get-tokens-and

  1. GET https://login.microsoftonline.com/<tenant_id>/oauth2/v2.0/authorize
     ?response_type=code
     &client_id=<client_id>
     &scope=offline_access https://storage.azure.com/.default
     &redirect_uri=http://localhost:8000/auth_flow
     &response_mode=query
     &state=1234

  2. POST https://login.microsoftonline.com/<tenant_id>/oauth2/v2.0/token
     client_id:<client_id>
     code:<code obtained from previous request>
     redirect_uri:http://localhost:8000/auth_flow
     grant_type:authorization_code
     client_secret:<client_secret>



  From this connector directory, run:

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



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



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



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

  ```
  poetry run pytest unit_tests
  ```



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

  ```bash
  airbyte-ci connectors --name=source-azure-blob-storage build
  ```

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



  Then run any of the connector commands as follows:

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



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

  ```bash
  airbyte-ci connectors --name=source-azure-blob-storage test
  ```



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



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

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

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



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

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


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




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



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



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



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


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


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

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



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


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


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


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

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


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


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




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

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



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





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


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

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



  Then run any of the connector commands as follows:

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




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

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



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





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



  From this connector directory, run:

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



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



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



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

  ```
  poetry run pytest unit_tests
  ```



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

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

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



  Then run any of the connector commands as follows:

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



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

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



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



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

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

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



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

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


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




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


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



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

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



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


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





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

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

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




  Then run any of the connector commands as follows:

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



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

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



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



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

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



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

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


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




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

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



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




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

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



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





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



  From this connector directory, run:

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



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



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



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

  ```
  poetry run pytest unit_tests
  ```



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

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

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



  Then run any of the connector commands as follows:

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



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

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



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



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

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

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



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

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


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





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

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



  Then run any of the connector commands as follows:

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





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




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

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




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-chargify:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-chargify:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-chargify:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-chargify: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-chargify 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-chargify 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/chargify.md`).
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/chargify.md`).
  5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
  6. Pat yourself on the back for being an awesome contributor.
  7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.
  8. Once your PR is merged, the new version of the connector will be automatically published to Docker Hub and our connector registry.


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





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

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




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





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

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




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

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




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


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





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

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



  Then run any of the connector commands as follows:

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




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



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



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



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


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


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

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



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


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


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


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

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


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


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





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

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



  Then run any of the connector commands as follows:

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

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



  Then run any of the connector commands as follows:

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




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

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



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





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

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




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




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



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



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



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


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


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

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



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


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


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


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

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


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


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




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

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



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




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

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



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





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

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



  Then run any of the connector commands as follows:

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




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

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



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




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



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



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



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


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


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

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



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


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


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


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

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


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


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





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

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



  Then run any of the connector commands as follows:

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

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




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


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




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

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-datadog:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-datadog:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-datadog:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-datadog: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-datadog 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-datadog 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`
  4. Make sure the connector documentation and its changelog is up to date (`docs/integrations/sources/datadog.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: 333d8cf6d80dd3b24ffdb1e89e4519c88a5a2aa518ad5d813d98329568dd5f67
name: python-airbyte-source-datadog-usage
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Source implementation for datadog-usage.
url: https://github.com/kesompochy/airbyte-source-datadog-usage
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-datadog-usage-0.2.5-1.src.rpm
checksum_type: sha256
description:
  In your airbyte workspace, create a new source from a container image.



  - Hourly usage by product `/api/v2/usage/hourly_usage`
  - Estimated cost `/api/v2/usage/estimated_cost`


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




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

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



  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-datascope:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-datascope:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-datascope:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-datascope: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-datascope 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-datascope 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/datascope.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: f5ec0c0e15c9e3b41512da22aa5b2d4dad371a45299ed9f82f883e87a7e1809e
name: python-airbyte-source-declarative-manifest
arch: src
version: 5.13.0
epoch: 0
release: 1
summary: Base source implementation for low-code sources.
url: https://airbyte.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-declarative-manifest-5.13.0-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Declarative-Manifest source connector, written in Python.
  The declarative manifest source connector is a special connector that can create an arbitrary source
  connector from a declarative manifest file. This allows users to create a source connector without writing any code.

  **Note**: This connector is managed by the Airbyte Python CDK release process. It can be run as a standalone connector
  in Docker and PyAirbyte, but is not yet meant to be run in the platform as a standalone connector. This source is
  an interface to the low-code CDK and as such, should not be modified without a corresponding CDK change.





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



  From this connector directory, run:

  ```bash
  poetry install
  ```



  The credentials for source-declarative-manifest are a little different. Your `config` will need to contain the
  injected declarative manifest, as indicated in the `spec`. It will also need to contain the fields that the spec
  coming out of the manifest requires. An example is available in `integration_tests/pokeapi_config.json`. To use
  this example in the following instructions, copy this file to `secrets/config.json`.



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

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



  Then run any of the connector commands as follows:

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

  This source does not currently pass the full test suite.



  The manifest declarative source is built to be an interface to the low-code CDK source. This means that
  this source should not have any production dependencies other than the Airbyte Python CDK. If for some reason
  you feel that a new dependency is needed, you likely want to add it to the CDK instead. It is expected
  that a given version of the source-declarative-manifest connector corresponds to the same version in
  its CDK dependency.



  New versions of this connector should only be published (automatically) via the manual Airbyte CDK release process.
  If you want to make a change to this connector that is not a result of a CDK change and a corresponding
  CDK dependency bump, please reach out to the Connector Extensibility team for guidance.


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





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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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





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

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




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

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



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





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



  From this connector directory, run:

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



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



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



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

  ```
  poetry run pytest unit_tests
  ```



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

  ```bash
  airbyte-ci connectors --name=source-facebook-marketing build
  ```

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



  Then run any of the connector commands as follows:

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



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

  ```bash
  airbyte-ci connectors --name=source-facebook-marketing test
  ```



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



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

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

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



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

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


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





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

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





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

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

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



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

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

  ```python
  from __future__ import annotations

  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      
      
      from dagger import Container


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

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



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

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

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

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

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




  ```

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

  2. Build your image:

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

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



  Then run any of the connector commands as follows:

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



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

  ```bash
  airbyte-ci connectors --name=source-facebook-pages test
  ```



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



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

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



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

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


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





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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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




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



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



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



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


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


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

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



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


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


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


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

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


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


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





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

  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.io/integrations/sources/firebolt)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_firebolt/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 firebolt 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
  ```





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

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

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

  **Via `docker build`:**

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



  Then run any of the connector commands as follows:

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


  View the Fleetio website [here](https://fleetio.com). For for information the Fleetio API, check out out [Fleetio API Portal](https://developer.fleetio.com).




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



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


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


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


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


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

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


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




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

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



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





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

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



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

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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




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

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



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





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

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



  Then run any of the connector commands as follows:

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




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

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



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





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

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

  **Via `docker build`:**

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



  Then run any of the connector commands as follows:

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





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

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



  Then run any of the connector commands as follows:

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




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



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



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



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


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


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

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



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


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


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


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

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


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


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




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

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



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





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



  From this connector directory, run:

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



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



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



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

  ```
  poetry run pytest unit_tests
  ```



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

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

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



  Then run any of the connector commands as follows:

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



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

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



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



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

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

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



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

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


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





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

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



  Then run any of the connector commands as follows:

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




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

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



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




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

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



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

  Currently we are not able to implement incremental streams with this source as the api does not allow a filter on updated at / last modified column. The link to the API documentation is available [here](https://customapi.goldcast.io/swagger-ui/#/).





  * 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/goldcast) to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `src/source_goldcast/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. For simplicity, instructions are also included here: please refer to the offical Goldcast [documentation](https://help.goldcast.io/hc/en-us/articles/22931655725723-How-To-Create-an-API-Token-in-Goldcast) to generate a token.




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

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




  Then run any of the connector commands as follows:
  ```
  docker run --rm airbyte/source-goldcast:dev spec
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-goldcast:dev check --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-goldcast:dev discover --config /secrets/config.json
  docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-goldcast: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-goldcast 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-goldcast 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/goldcast.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: 6be75046156a5436769438e21a77019fb40db81c36367799b6c99fa60ab347cc
name: python-airbyte-source-google-ads
arch: src
version: 3.7.9
epoch: 0
release: 1
summary: Source implementation for Google Ads.
url: https://airbyte.com
rpm_license: Elv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-airbyte-source-google-ads-3.7.9-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the Google-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/google-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/google-ads)
  to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_google_ads/spec.yaml` file.
  Note that any directory named `secrets` is gitignored across the entire Airbyte repo, so there is no danger of accidentally checking in sensitive information.
  See `sample_files/sample_config.json` for a sample config file.



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

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



  Then run any of the connector commands as follows:

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





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



  From this connector directory, run:

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



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



  ```
  poetry run source-google-analytics-data-api spec
  poetry run source-google-analytics-data-api check --config secrets/config.json
  poetry run source-google-analytics-data-api discover --config secrets/config.json
  poetry run source-google-analytics-data-api read --config secrets/config.json --catalog sample_files/configured_catalog.json
  ```



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

  ```
  poetry run pytest unit_tests
  ```



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

  ```bash
  airbyte-ci connectors --name=source-google-analytics-data-api build
  ```

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



  Then run any of the connector commands as follows:

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



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

  ```bash
  airbyte-ci connectors --name=source-google-analytics-data-api test
  ```



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



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

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

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



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

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


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




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



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



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



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


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


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

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



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


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


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


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

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


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


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





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



  From this connector directory, run:

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



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



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



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

  ```
  poetry run pytest unit_tests
  ```



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

  ```bash
  airbyte-ci connectors --name=source-google-pagespeed-insights build
  ```

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



  Then run any of the connector commands as follows:

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



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

  ```bash
  airbyte-ci connectors --name=source-google-pagespeed-insights test
  ```



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



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

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

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



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

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





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



  From this connector directory, run:

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



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



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



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

  ```
  poetry run pytest unit_tests
  ```



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

  ```bash
  airbyte-ci connectors --name=source-google-search-console build
  ```

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



  Then run any of the connector commands as follows:

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



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

  ```bash
  airbyte-ci connectors --name=source-google-search-console test
  ```



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



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

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

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



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

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


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





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



  From this connector directory, run:

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



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



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



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

  ```
  poetry run pytest unit_tests
  ```



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

  ```bash
  airbyte-ci connectors --name=source-google-sheets build
  ```

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



  Then run any of the connector commands as follows:

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



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

  ```bash
  airbyte-ci connectors --name=source-google-sheets test
  ```



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



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

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

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



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

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





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



  From this connector directory, run:

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



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



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



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

  ```
  poetry run pytest unit_tests
  ```



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

  ```bash
  airbyte-ci connectors --name=source-google-webfonts build
  ```

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



  Then run any of the connector commands as follows:

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



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

  ```bash
  airbyte-ci connectors --name=source-google-webfonts test
  ```



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



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

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

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



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

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





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



  From this connector directory, run:

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



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



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



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

  ```
  poetry run pytest unit_tests
  ```



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

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

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



  Then run any of the connector commands as follows:

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



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

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



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



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

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

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



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

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


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




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



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



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



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


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


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

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



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


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


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


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

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


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


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




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

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



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





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



  From this connector directory, run:

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



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



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



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

  ```
  poetry run pytest unit_tests
  ```



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

  ```bash
  airbyte-ci connectors --name=source-hardcoded-records build
  ```

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



  Then run any of the connector commands as follows:

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



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

  ```bash
  airbyte-ci connectors --name=source-hardcoded-records test
  ```



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



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

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

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



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

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


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




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

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



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





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

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



  Then run any of the connector commands as follows:

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




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

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



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




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

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



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





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



  From this connector directory, run:

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



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



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



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

  ```
  poetry run pytest unit_tests
  ```



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

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

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



  Then run any of the connector commands as follows:

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



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

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



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



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

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

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



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

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


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





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

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



  Then run any of the connector commands as follows:

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


