airbyte-source-google-drive 0.0.8__py3-none-any.whl

airbyte_source_google_drive-0.0.8.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.1
+Name: airbyte-source-google-drive
+Version: 0.0.8
+Summary: Source implementation for Google Drive.
+Author: Airbyte
+Author-email: contact@airbyte.io
+Description-Content-Type: text/markdown
+Requires-Dist: airbyte-cdk[file-based] >=0.60.1
+Requires-Dist: google-api-python-client ==2.104.0
+Requires-Dist: google-auth-httplib2 ==0.1.1
+Requires-Dist: google-auth-oauthlib ==1.1.0
+Requires-Dist: google-api-python-client-stubs ==1.18.0
+Provides-Extra: tests
+Requires-Dist: pytest-mock ~=3.6.1 ; extra == 'tests'
+Requires-Dist: pytest ~=6.1 ; extra == 'tests'
+
+# Google Drive Source
+
+This is the repository for the Google Drive source connector, written in Python.
+For information about how to use this connector within Airbyte, see [the documentation](https://docs.airbyte.io/integrations/sources/google-drive).
+
+
+**To iterate on this connector, make sure to complete this prerequisites section.**
+
+
+From this connector directory, create a virtual environment:
+```
+python -m venv .venv
+```
+
+This will generate a virtualenv for this module in `.venv/`. Make sure this venv is active in your
+development environment of choice. To activate it from the terminal, run:
+```
+source .venv/bin/activate
+pip install -r requirements.txt
+pip install '.[tests]'
+```
+If you are in an IDE, follow your IDE's instructions to activate the virtualenv.
+
+Note that while we are installing dependencies from `requirements.txt`, you should only edit `setup.py` for your dependencies. `requirements.txt` is
+used for editable installs (`pip install -e`) to pull in Python dependencies from the monorepo and will call `setup.py`.
+If this is mumbo jumbo to you, don't worry about it, just put your deps in `setup.py` but install using `pip install -r requirements.txt` and everything
+should work as you expect.
+
+**If you are a community contributor**, follow the instructions in the [documentation](https://docs.airbyte.io/integrations/sources/google-drive)
+to generate the necessary credentials. Then create a file `secrets/config.json` conforming to the `source_google_drive/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 google-drive 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-google-drive build
+```
+
+An image will be built with the tag `airbyte/source-google-drive:dev`.
+
+**Via `docker build`:**
+```bash
+docker build -t airbyte/source-google-drive:dev .
+```
+
+Then run any of the connector commands as follows:
+```
+docker run --rm airbyte/source-google-drive:dev spec
+docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-google-drive:dev check --config /secrets/config.json
+docker run --rm -v $(pwd)/secrets:/secrets airbyte/source-google-drive:dev discover --config /secrets/config.json
+docker run --rm -v $(pwd)/secrets:/secrets -v $(pwd)/integration_tests:/integration_tests airbyte/source-google-drive:dev read --config /secrets/config.json --catalog /integration_tests/configured_catalog.json
+```
+
+You can run our full test 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-drive 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-google-drive 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/google-drive.md`).
+5. Create a Pull Request: use [our PR naming conventions](https://docs.airbyte.com/contributing-to-airbyte/resources/pull-requests-handbook/#pull-request-title-convention).
+6. Pat yourself on the back for being an awesome contributor.
+7. Someone from Airbyte will take a look at your PR and iterate with you to merge it into master.

airbyte_source_google_drive-0.0.8.dist-info/RECORD

@@ -0,0 +1,17 @@
+integration_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+integration_tests/abnormal_state.json,sha256=OjtTybZAAaINLABJKWytuOVczeJV_F00pGa7cH8M3vU,986
+integration_tests/acceptance.py,sha256=q5rKj8jSnWg7fFZu2y7tsBwrbKsoxbAgKP43-FQ8Vc4,361
+integration_tests/configured_catalog.json,sha256=WaPXCRHx2Pv96Uyci_4eKA07VLQ-JxEYi24l8KqahEI,1600
+integration_tests/invalid_config.json,sha256=36BpdsPLMC-89lYg-eZL0SVi_zPWKx9WJnfmix_g2w0,403
+integration_tests/spec.json,sha256=a1WQD1cKsyZQQ3eKK_cJym0ftop05JUaIpfCVvqpe8o,21010
+source_google_drive/__init__.py,sha256=5eaSfjduFy2tZFKWshVu1H7Evu-pjwOdti4MGDANCj4,132
+source_google_drive/run.py,sha256=R5AQ5KyVwlhCDqVeNq9zRZa9cROB1PwxDBz9fW0d7RE,711
+source_google_drive/source.py,sha256=PAEoNKumyLWQpSk3zNQ0B9jdlltZCfLLghcmQY8bjGk,2827
+source_google_drive/spec.py,sha256=A25glT8IV4hngtv7goVK3xIV0r0uwy_qOvJER9Q6VKI,3401
+source_google_drive/stream_reader.py,sha256=bRgGeSKOQLLASwZGli9juzdpSTwBzureAziKs42j4MQ,8533
+source_google_drive/utils.py,sha256=ZIYqXEQfJDpFZgNW94MOeYPG2xKba-LoGgsYEllhVmY,941
+airbyte_source_google_drive-0.0.8.dist-info/METADATA,sha256=Gx7pEK1Id8olLctCFE8Sd4GXREHxzAMkQqU4k0jWiIU,5639
+airbyte_source_google_drive-0.0.8.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+airbyte_source_google_drive-0.0.8.dist-info/entry_points.txt,sha256=rZDJ3rREvJ7j4Oew33J5eOBHfJkdjFaidKSmwVBrS3A,68
+airbyte_source_google_drive-0.0.8.dist-info/top_level.txt,sha256=Tj-bdDutVStfs3X15D0Z8bx2thMV9sAaYr9KgguAFDc,38
+airbyte_source_google_drive-0.0.8.dist-info/RECORD,,

airbyte_source_google_drive-0.0.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

airbyte_source_google_drive-0.0.8.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+source-google-drive = source_google_drive.run:run

airbyte_source_google_drive-0.0.8.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+integration_tests
+source_google_drive

integration_tests/abnormal_state.json

@@ -0,0 +1,35 @@
+[
+  {
+    "type": "STREAM",
+    "stream": {
+      "stream_descriptor": {
+        "name": "test"
+      },
+      "stream_state": {
+        "history": {
+          "test.jsonl": "2023-10-16T06:16:06.000000Z",
+          "subfolder/test2.jsonl": "2023-10-19T01:43:56.000000Z"
+        },
+        "_ab_source_file_last_modified": "2023-10-19T01:43:56.000000Z_subfolder/test2.jsonl"
+      }
+    }
+  },
+  {
+    "type": "STREAM",
+    "stream": {
+      "stream_descriptor": {
+        "name": "test_unstructured"
+      },
+      "stream_state": {
+        "history": {
+          "testdoc_docx.docx": "2023-10-27T00:45:54.000000Z",
+          "testdoc_pdf.pdf": "2023-10-27T00:45:58.000000Z",
+          "testdoc_ocr_pdf.pdf": "2023-10-27T00:46:04.000000Z",
+          "testdoc_google": "2023-11-10T13:46:18.551000Z",
+          "testdoc_presentation": "2023-11-10T13:49:06.640000Z"
+        },
+        "_ab_source_file_last_modified": "2023-11-10T13:49:06.640000Z_testdoc_presentation"
+      }
+    }
+  }
+]

integration_tests/acceptance.py

@@ -0,0 +1,16 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+
+from typing import Iterable
+
+import pytest
+
+pytest_plugins = ("connector_acceptance_test.plugin",)
+
+
+@pytest.fixture(scope="session", autouse=True)
+def connector_setup() -> Iterable[None]:
+    """This fixture is a placeholder for external resources that acceptance test might require."""
+    yield

integration_tests/configured_catalog.json

@@ -0,0 +1,60 @@
+{
+  "streams": [
+    {
+      "stream": {
+        "name": "test",
+        "json_schema": {
+          "type": "object",
+          "properties": {
+            "y": {
+              "type": ["null", "integer"]
+            },
+            "x": {
+              "type": ["null", "integer"]
+            },
+            "_ab_source_file_last_modified": {
+              "type": "string",
+              "format": "date-time"
+            },
+            "_ab_source_file_url": {
+              "type": "string"
+            }
+          }
+        },
+        "supported_sync_modes": ["full_refresh", "incremental"],
+        "source_defined_cursor": true,
+        "default_cursor_field": ["_ab_source_file_last_modified"]
+      },
+      "sync_mode": "incremental",
+      "destination_sync_mode": "append"
+    },
+    {
+      "stream": {
+        "name": "test_unstructured",
+        "json_schema": {
+          "type": "object",
+          "properties": {
+            "document_key": {
+              "type": ["null", "integer"]
+            },
+            "content": {
+              "type": ["null", "integer"]
+            },
+            "_ab_source_file_last_modified": {
+              "type": "string",
+              "format": "date-time"
+            },
+            "_ab_source_file_url": {
+              "type": "string"
+            }
+          }
+        },
+        "supported_sync_modes": ["full_refresh", "incremental"],
+        "source_defined_cursor": true,
+        "default_cursor_field": ["_ab_source_file_last_modified"]
+      },
+      "sync_mode": "incremental",
+      "destination_sync_mode": "append"
+    }
+  ]
+}

integration_tests/invalid_config.json

@@ -0,0 +1,19 @@
+{
+  "folder_url": "https://drive.google.com/drive/folders/yyy",
+  "credentials": {
+    "auth_type": "Service",
+    "service_account_info": "abc"
+  },
+  "streams": [
+    {
+      "name": "test",
+      "globs": ["**/*.jsonl"],
+      "format": {
+        "filetype": "jsonl"
+      },
+      "schemaless": false,
+      "validation_policy": "Emit Record",
+      "days_to_sync_if_history_is_full": 3
+    }
+  ]
+}

integration_tests/spec.json

@@ -0,0 +1,456 @@
+{
+  "documentationUrl": "https://docs.airbyte.com/integrations/sources/google-drive",
+  "connectionSpecification": {
+    "title": "Google Drive Source Spec",
+    "description": "Used during spec; allows the developer to configure the cloud provider specific options\nthat are needed when users configure a file-based source.",
+    "type": "object",
+    "properties": {
+      "start_date": {
+        "title": "Start Date",
+        "description": "UTC date and time in the format 2017-01-25T00:00:00.000000Z. Any file modified before this date will not be replicated.",
+        "examples": ["2021-01-01T00:00:00.000000Z"],
+        "format": "date-time",
+        "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}.[0-9]{6}Z$",
+        "pattern_descriptor": "YYYY-MM-DDTHH:mm:ss.SSSSSSZ",
+        "order": 1,
+        "type": "string"
+      },
+      "streams": {
+        "title": "The list of streams to sync",
+        "description": "Each instance of this configuration defines a <a href=\"https://docs.airbyte.com/cloud/core-concepts#stream\">stream</a>. Use this to define which files belong in the stream, their format, and how they should be parsed and validated. When sending data to warehouse destination such as Snowflake or BigQuery, each stream is a separate table.",
+        "order": 10,
+        "type": "array",
+        "items": {
+          "title": "FileBasedStreamConfig",
+          "type": "object",
+          "properties": {
+            "name": {
+              "title": "Name",
+              "description": "The name of the stream.",
+              "type": "string"
+            },
+            "globs": {
+              "title": "Globs",
+              "default": ["**"],
+              "order": 1,
+              "description": "The pattern used to specify which files should be selected from the file system. For more information on glob pattern matching look <a href=\"https://en.wikipedia.org/wiki/Glob_(programming)\">here</a>.",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "validation_policy": {
+              "title": "Validation Policy",
+              "description": "The name of the validation policy that dictates sync behavior when a record does not adhere to the stream schema.",
+              "default": "Emit Record",
+              "enum": ["Emit Record", "Skip Record", "Wait for Discover"]
+            },
+            "input_schema": {
+              "title": "Input Schema",
+              "description": "The schema that will be used to validate records extracted from the file. This will override the stream schema that is auto-detected from incoming files.",
+              "type": "string"
+            },
+            "primary_key": {
+              "title": "Primary Key",
+              "description": "The column or columns (for a composite key) that serves as the unique identifier of a record. If empty, the primary key will default to the parser's default primary key.",
+              "type": "string",
+              "airbyte_hidden": true
+            },
+            "days_to_sync_if_history_is_full": {
+              "title": "Days To Sync If History Is Full",
+              "description": "When the state history of the file store is full, syncs will only read files that were last modified in the provided day range.",
+              "default": 3,
+              "type": "integer"
+            },
+            "format": {
+              "title": "Format",
+              "description": "The configuration options that are used to alter how to read incoming files that deviate from the standard formatting.",
+              "type": "object",
+              "oneOf": [
+                {
+                  "title": "Avro Format",
+                  "type": "object",
+                  "properties": {
+                    "filetype": {
+                      "title": "Filetype",
+                      "default": "avro",
+                      "const": "avro",
+                      "type": "string"
+                    },
+                    "double_as_string": {
+                      "title": "Convert Double Fields to Strings",
+                      "description": "Whether to convert double fields to strings. This is recommended if you have decimal numbers with a high degree of precision because there can be a loss precision when handling floating point numbers.",
+                      "default": false,
+                      "type": "boolean"
+                    }
+                  },
+                  "required": ["filetype"]
+                },
+                {
+                  "title": "CSV Format",
+                  "type": "object",
+                  "properties": {
+                    "filetype": {
+                      "title": "Filetype",
+                      "default": "csv",
+                      "const": "csv",
+                      "type": "string"
+                    },
+                    "delimiter": {
+                      "title": "Delimiter",
+                      "description": "The character delimiting individual cells in the CSV data. This may only be a 1-character string. For tab-delimited data enter '\\t'.",
+                      "default": ",",
+                      "type": "string"
+                    },
+                    "quote_char": {
+                      "title": "Quote Character",
+                      "description": "The character used for quoting CSV values. To disallow quoting, make this field blank.",
+                      "default": "\"",
+                      "type": "string"
+                    },
+                    "escape_char": {
+                      "title": "Escape Character",
+                      "description": "The character used for escaping special characters. To disallow escaping, leave this field blank.",
+                      "type": "string"
+                    },
+                    "encoding": {
+                      "title": "Encoding",
+                      "description": "The character encoding of the CSV data. Leave blank to default to <strong>UTF8</strong>. See <a href=\"https://docs.python.org/3/library/codecs.html#standard-encodings\" target=\"_blank\">list of python encodings</a> for allowable options.",
+                      "default": "utf8",
+                      "type": "string"
+                    },
+                    "double_quote": {
+                      "title": "Double Quote",
+                      "description": "Whether two quotes in a quoted CSV value denote a single quote in the data.",
+                      "default": true,
+                      "type": "boolean"
+                    },
+                    "null_values": {
+                      "title": "Null Values",
+                      "description": "A set of case-sensitive strings that should be interpreted as null values. For example, if the value 'NA' should be interpreted as null, enter 'NA' in this field.",
+                      "default": [],
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      },
+                      "uniqueItems": true
+                    },
+                    "strings_can_be_null": {
+                      "title": "Strings Can Be Null",
+                      "description": "Whether strings can be interpreted as null values. If true, strings that match the null_values set will be interpreted as null. If false, strings that match the null_values set will be interpreted as the string itself.",
+                      "default": true,
+                      "type": "boolean"
+                    },
+                    "skip_rows_before_header": {
+                      "title": "Skip Rows Before Header",
+                      "description": "The number of rows to skip before the header row. For example, if the header row is on the 3rd row, enter 2 in this field.",
+                      "default": 0,
+                      "type": "integer"
+                    },
+                    "skip_rows_after_header": {
+                      "title": "Skip Rows After Header",
+                      "description": "The number of rows to skip after the header row.",
+                      "default": 0,
+                      "type": "integer"
+                    },
+                    "header_definition": {
+                      "title": "CSV Header Definition",
+                      "description": "How headers will be defined. `User Provided` assumes the CSV does not have a header row and uses the headers provided and `Autogenerated` assumes the CSV does not have a header row and the CDK will generate headers using for `f{i}` where `i` is the index starting from 0. Else, the default behavior is to use the header from the CSV file. If a user wants to autogenerate or provide column names for a CSV having headers, they can skip rows.",
+                      "default": {
+                        "header_definition_type": "From CSV"
+                      },
+                      "oneOf": [
+                        {
+                          "title": "From CSV",
+                          "type": "object",
+                          "properties": {
+                            "header_definition_type": {
+                              "title": "Header Definition Type",
+                              "default": "From CSV",
+                              "const": "From CSV",
+                              "type": "string"
+                            }
+                          },
+                          "required": ["header_definition_type"]
+                        },
+                        {
+                          "title": "Autogenerated",
+                          "type": "object",
+                          "properties": {
+                            "header_definition_type": {
+                              "title": "Header Definition Type",
+                              "default": "Autogenerated",
+                              "const": "Autogenerated",
+                              "type": "string"
+                            }
+                          },
+                          "required": ["header_definition_type"]
+                        },
+                        {
+                          "title": "User Provided",
+                          "type": "object",
+                          "properties": {
+                            "header_definition_type": {
+                              "title": "Header Definition Type",
+                              "default": "User Provided",
+                              "const": "User Provided",
+                              "type": "string"
+                            },
+                            "column_names": {
+                              "title": "Column Names",
+                              "description": "The column names that will be used while emitting the CSV records",
+                              "type": "array",
+                              "items": {
+                                "type": "string"
+                              }
+                            }
+                          },
+                          "required": ["column_names", "header_definition_type"]
+                        }
+                      ],
+                      "type": "object"
+                    },
+                    "true_values": {
+                      "title": "True Values",
+                      "description": "A set of case-sensitive strings that should be interpreted as true values.",
+                      "default": ["y", "yes", "t", "true", "on", "1"],
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      },
+                      "uniqueItems": true
+                    },
+                    "false_values": {
+                      "title": "False Values",
+                      "description": "A set of case-sensitive strings that should be interpreted as false values.",
+                      "default": ["n", "no", "f", "false", "off", "0"],
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      },
+                      "uniqueItems": true
+                    }
+                  },
+                  "required": ["filetype"]
+                },
+                {
+                  "title": "Jsonl Format",
+                  "type": "object",
+                  "properties": {
+                    "filetype": {
+                      "title": "Filetype",
+                      "default": "jsonl",
+                      "const": "jsonl",
+                      "type": "string"
+                    }
+                  },
+                  "required": ["filetype"]
+                },
+                {
+                  "title": "Parquet Format",
+                  "type": "object",
+                  "properties": {
+                    "filetype": {
+                      "title": "Filetype",
+                      "default": "parquet",
+                      "const": "parquet",
+                      "type": "string"
+                    },
+                    "decimal_as_float": {
+                      "title": "Convert Decimal Fields to Floats",
+                      "description": "Whether to convert decimal fields to floats. There is a loss of precision when converting decimals to floats, so this is not recommended.",
+                      "default": false,
+                      "type": "boolean"
+                    }
+                  },
+                  "required": ["filetype"]
+                },
+                {
+                  "title": "Document File Type Format (Experimental)",
+                  "type": "object",
+                  "properties": {
+                    "filetype": {
+                      "title": "Filetype",
+                      "default": "unstructured",
+                      "const": "unstructured",
+                      "type": "string"
+                    },
+                    "skip_unprocessable_files": {
+                      "type": "boolean",
+                      "default": true,
+                      "title": "Skip Unprocessable Files",
+                      "description": "If true, skip files that cannot be parsed and pass the error message along as the _ab_source_file_parse_error field. If false, fail the sync.",
+                      "always_show": true
+                    },
+                    "strategy": {
+                      "type": "string",
+                      "always_show": true,
+                      "order": 0,
+                      "default": "auto",
+                      "title": "Parsing Strategy",
+                      "enum": ["auto", "fast", "ocr_only", "hi_res"],
+                      "description": "The strategy used to parse documents. `fast` extracts text directly from the document which doesn't work for all files. `ocr_only` is more reliable, but slower. `hi_res` is the most reliable, but requires an API key and a hosted instance of unstructured and can't be used with local mode. See the unstructured.io documentation for more details: https://unstructured-io.github.io/unstructured/core/partition.html#partition-pdf"
+                    },
+                    "processing": {
+                      "title": "Processing",
+                      "description": "Processing configuration",
+                      "default": {
+                        "mode": "local"
+                      },
+                      "type": "object",
+                      "oneOf": [
+                        {
+                          "title": "Local",
+                          "type": "object",
+                          "properties": {
+                            "mode": {
+                              "title": "Mode",
+                              "default": "local",
+                              "const": "local",
+                              "enum": ["local"],
+                              "type": "string"
+                            }
+                          },
+                          "description": "Process files locally, supporting `fast` and `ocr` modes. This is the default option.",
+                          "required": ["mode"]
+                        }
+                      ]
+                    }
+                  },
+                  "description": "Extract text from document formats (.pdf, .docx, .md, .pptx) and emit as one record per file.",
+                  "required": ["filetype"]
+                }
+              ]
+            },
+            "schemaless": {
+              "title": "Schemaless",
+              "description": "When enabled, syncs will not validate or structure records against the stream's schema.",
+              "default": false,
+              "type": "boolean"
+            }
+          },
+          "required": ["name", "format"]
+        }
+      },
+      "folder_url": {
+        "title": "Folder Url",
+        "description": "URL for the folder you want to sync. Using individual streams and glob patterns, it's possible to only sync a subset of all files located in the folder.",
+        "examples": [
+          "https://drive.google.com/drive/folders/1Xaz0vXXXX2enKnNYU5qSt9NS70gvMyYn"
+        ],
+        "order": 0,
+        "pattern": "^https://drive.google.com/.+",
+        "pattern_descriptor": "https://drive.google.com/drive/folders/MY-FOLDER-ID",
+        "type": "string"
+      },
+      "credentials": {
+        "title": "Authentication",
+        "description": "Credentials for connecting to the Google Drive API",
+        "type": "object",
+        "oneOf": [
+          {
+            "title": "Authenticate via Google (OAuth)",
+            "type": "object",
+            "properties": {
+              "auth_type": {
+                "title": "Auth Type",
+                "default": "Client",
+                "const": "Client",
+                "enum": ["Client"],
+                "type": "string"
+              },
+              "client_id": {
+                "title": "Client ID",
+                "description": "Client ID for the Google Drive API",
+                "airbyte_secret": true,
+                "type": "string"
+              },
+              "client_secret": {
+                "title": "Client Secret",
+                "description": "Client Secret for the Google Drive API",
+                "airbyte_secret": true,
+                "type": "string"
+              },
+              "refresh_token": {
+                "title": "Refresh Token",
+                "description": "Refresh Token for the Google Drive API",
+                "airbyte_secret": true,
+                "type": "string"
+              }
+            },
+            "required": [
+              "client_id",
+              "client_secret",
+              "refresh_token",
+              "auth_type"
+            ]
+          },
+          {
+            "title": "Service Account Key Authentication",
+            "type": "object",
+            "properties": {
+              "auth_type": {
+                "title": "Auth Type",
+                "default": "Service",
+                "const": "Service",
+                "enum": ["Service"],
+                "type": "string"
+              },
+              "service_account_info": {
+                "title": "Service Account Information",
+                "description": "The JSON key of the service account to use for authorization. Read more <a href=\"https://cloud.google.com/iam/docs/creating-managing-service-account-keys#creating_service_account_keys\">here</a>.",
+                "airbyte_secret": true,
+                "type": "string"
+              }
+            },
+            "required": ["service_account_info", "auth_type"]
+          }
+        ]
+      }
+    },
+    "required": ["streams", "folder_url", "credentials"]
+  },
+  "advanced_auth": {
+    "auth_flow_type": "oauth2.0",
+    "predicate_key": ["credentials", "auth_type"],
+    "predicate_value": "Client",
+    "oauth_config_specification": {
+      "complete_oauth_output_specification": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "refresh_token": {
+            "type": "string",
+            "path_in_connector_config": ["credentials", "refresh_token"]
+          }
+        }
+      },
+      "complete_oauth_server_input_specification": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "client_id": {
+            "type": "string"
+          },
+          "client_secret": {
+            "type": "string"
+          }
+        }
+      },
+      "complete_oauth_server_output_specification": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "client_id": {
+            "type": "string",
+            "path_in_connector_config": ["credentials", "client_id"]
+          },
+          "client_secret": {
+            "type": "string",
+            "path_in_connector_config": ["credentials", "client_secret"]
+          }
+        }
+      }
+    }
+  }
+}

source_google_drive/__init__.py

@@ -0,0 +1,6 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+from .source import SourceGoogleDrive
+
+__all__ = ["SourceGoogleDrive"]

source_google_drive/run.py

@@ -0,0 +1,23 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+
+import sys
+
+from airbyte_cdk import AirbyteEntrypoint
+from airbyte_cdk.entrypoint import launch
+from source_google_drive import SourceGoogleDrive
+
+
+def run():
+    args = sys.argv[1:]
+    catalog_path = AirbyteEntrypoint.extract_catalog(args)
+    config_path = AirbyteEntrypoint.extract_config(args)
+    state_path = AirbyteEntrypoint.extract_state(args)
+    source = SourceGoogleDrive(
+        SourceGoogleDrive.read_catalog(catalog_path) if catalog_path else None,
+        SourceGoogleDrive.read_config(config_path) if config_path else None,
+        SourceGoogleDrive.read_state(state_path) if state_path else None,
+    )
+    launch(source, args)

source_google_drive/source.py

@@ -0,0 +1,58 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+from typing import Any, Mapping, Optional
+
+from airbyte_cdk.models import AdvancedAuth, ConfiguredAirbyteCatalog, ConnectorSpecification, OAuthConfigSpecification
+from airbyte_cdk.sources.file_based.file_based_source import FileBasedSource
+from airbyte_cdk.sources.file_based.stream.cursor.default_file_based_cursor import DefaultFileBasedCursor
+from airbyte_cdk.sources.source import TState
+from source_google_drive.spec import SourceGoogleDriveSpec
+from source_google_drive.stream_reader import SourceGoogleDriveStreamReader
+
+
+class SourceGoogleDrive(FileBasedSource):
+    def __init__(self, catalog: Optional[ConfiguredAirbyteCatalog], config: Optional[Mapping[str, Any]], state: Optional[TState]):
+        super().__init__(
+            stream_reader=SourceGoogleDriveStreamReader(),
+            spec_class=SourceGoogleDriveSpec,
+            catalog=catalog,
+            config=config,
+            state=state,
+            cursor_cls=DefaultFileBasedCursor,
+        )
+
+    def spec(self, *args: Any, **kwargs: Any) -> ConnectorSpecification:
+        """
+        Returns the specification describing what fields can be configured by a user when setting up a file-based source.
+        """
+
+        return ConnectorSpecification(
+            documentationUrl=self.spec_class.documentation_url(),
+            connectionSpecification=self.spec_class.schema(),
+            advanced_auth=AdvancedAuth(
+                auth_flow_type="oauth2.0",
+                predicate_key=["credentials", "auth_type"],
+                predicate_value="Client",
+                oauth_config_specification=OAuthConfigSpecification(
+                    complete_oauth_output_specification={
+                        "type": "object",
+                        "additionalProperties": False,
+                        "properties": {"refresh_token": {"type": "string", "path_in_connector_config": ["credentials", "refresh_token"]}},
+                    },
+                    complete_oauth_server_input_specification={
+                        "type": "object",
+                        "additionalProperties": False,
+                        "properties": {"client_id": {"type": "string"}, "client_secret": {"type": "string"}},
+                    },
+                    complete_oauth_server_output_specification={
+                        "type": "object",
+                        "additionalProperties": False,
+                        "properties": {
+                            "client_id": {"type": "string", "path_in_connector_config": ["credentials", "client_id"]},
+                            "client_secret": {"type": "string", "path_in_connector_config": ["credentials", "client_secret"]},
+                        },
+                    },
+                ),
+            ),
+        )

source_google_drive/spec.py

@@ -0,0 +1,85 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+
+from typing import Any, Dict, Literal, Union
+
+import dpath.util
+from airbyte_cdk.sources.file_based.config.abstract_file_based_spec import AbstractFileBasedSpec
+from airbyte_cdk.utils.oneof_option_config import OneOfOptionConfig
+from pydantic import BaseModel, Field
+
+
+class OAuthCredentials(BaseModel):
+    class Config(OneOfOptionConfig):
+        title = "Authenticate via Google (OAuth)"
+        discriminator = "auth_type"
+
+    auth_type: Literal["Client"] = Field("Client", const=True)
+    client_id: str = Field(
+        title="Client ID",
+        description="Client ID for the Google Drive API",
+        airbyte_secret=True,
+    )
+    client_secret: str = Field(
+        title="Client Secret",
+        description="Client Secret for the Google Drive API",
+        airbyte_secret=True,
+    )
+    refresh_token: str = Field(
+        title="Refresh Token",
+        description="Refresh Token for the Google Drive API",
+        airbyte_secret=True,
+    )
+
+
+class ServiceAccountCredentials(BaseModel):
+    class Config(OneOfOptionConfig):
+        title = "Service Account Key Authentication"
+        discriminator = "auth_type"
+
+    auth_type: Literal["Service"] = Field("Service", const=True)
+    service_account_info: str = Field(
+        title="Service Account Information",
+        description='The JSON key of the service account to use for authorization. Read more <a href="https://cloud.google.com/iam/docs/creating-managing-service-account-keys#creating_service_account_keys">here</a>.',
+        airbyte_secret=True,
+    )
+
+
+class SourceGoogleDriveSpec(AbstractFileBasedSpec, BaseModel):
+    class Config:
+        title = "Google Drive Source Spec"
+
+    folder_url: str = Field(
+        description="URL for the folder you want to sync. Using individual streams and glob patterns, it's possible to only sync a subset of all files located in the folder.",
+        examples=["https://drive.google.com/drive/folders/1Xaz0vXXXX2enKnNYU5qSt9NS70gvMyYn"],
+        order=0,
+        pattern="^https://drive.google.com/.+",
+        pattern_descriptor="https://drive.google.com/drive/folders/MY-FOLDER-ID",
+    )
+
+    credentials: Union[OAuthCredentials, ServiceAccountCredentials] = Field(
+        title="Authentication", description="Credentials for connecting to the Google Drive API", discriminator="auth_type", type="object"
+    )
+
+    @classmethod
+    def documentation_url(cls) -> str:
+        return "https://docs.airbyte.com/integrations/sources/google-drive"
+
+    @classmethod
+    def schema(cls, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Generates the mapping comprised of the config fields
+        """
+        schema = super().schema(*args, **kwargs)
+
+        # Remove legacy settings
+        dpath.util.delete(schema, "properties/streams/items/properties/legacy_prefix")
+        dpath.util.delete(schema, "properties/streams/items/properties/format/oneOf/*/properties/inference_type")
+
+        # Hide API processing option until https://github.com/airbytehq/airbyte-platform-internal/issues/10354 is fixed
+        processing_options = dpath.util.get(schema, "properties/streams/items/properties/format/oneOf/4/properties/processing/oneOf")
+        dpath.util.set(schema, "properties/streams/items/properties/format/oneOf/4/properties/processing/oneOf", processing_options[:1])
+
+        return schema

source_google_drive/stream_reader.py

@@ -0,0 +1,185 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+import io
+import json
+import logging
+import re
+from datetime import datetime
+from io import IOBase
+from typing import Iterable, List, Optional, Set
+
+from airbyte_cdk.sources.file_based.file_based_stream_reader import AbstractFileBasedStreamReader, FileReadMode
+from airbyte_cdk.sources.file_based.remote_file import RemoteFile
+from airbyte_cdk.utils.traced_exception import AirbyteTracedException, FailureType
+from google.oauth2 import credentials, service_account
+from googleapiclient.discovery import build
+from googleapiclient.http import MediaIoBaseDownload
+from source_google_drive.utils import get_folder_id
+
+from .spec import SourceGoogleDriveSpec
+
+FOLDER_MIME_TYPE = "application/vnd.google-apps.folder"
+GOOGLE_DOC_MIME_TYPE = "application/vnd.google-apps.document"
+EXPORTABLE_DOCUMENTS_MIME_TYPES = [
+    GOOGLE_DOC_MIME_TYPE,
+    "application/vnd.google-apps.presentation",
+    "application/vnd.google-apps.drawing",
+]
+
+
+class GoogleDriveRemoteFile(RemoteFile):
+    id: str
+    # The mime type of the file as returned by the Google Drive API
+    # This is not the same as the mime type when opened by the parser (e.g. google docs is exported as docx)
+    original_mime_type: str
+
+
+class SourceGoogleDriveStreamReader(AbstractFileBasedStreamReader):
+    def __init__(self):
+        super().__init__()
+        self._drive_service = None
+
+    @property
+    def config(self) -> SourceGoogleDriveSpec:
+        return self._config
+
+    @config.setter
+    def config(self, value: SourceGoogleDriveSpec):
+        """
+        FileBasedSource reads the config from disk and parses it, and once parsed, the source sets the config on its StreamReader.
+
+        Note: FileBasedSource only requires the keys defined in the abstract config, whereas concrete implementations of StreamReader
+        will require keys that (for example) allow it to authenticate with the 3rd party.
+
+        Therefore, concrete implementations of AbstractFileBasedStreamReader's config setter should assert that `value` is of the correct
+        config type for that type of StreamReader.
+        """
+        assert isinstance(value, SourceGoogleDriveSpec)
+        self._config = value
+
+    @property
+    def google_drive_service(self):
+        if self.config is None:
+            # We shouldn't hit this; config should always get set before attempting to
+            # list or read files.
+            raise ValueError("Source config is missing; cannot create the Google Drive client.")
+        try:
+            if self._drive_service is None:
+                if self.config.credentials.auth_type == "Client":
+                    creds = credentials.Credentials.from_authorized_user_info(self.config.credentials.dict())
+                else:
+                    creds = service_account.Credentials.from_service_account_info(json.loads(self.config.credentials.service_account_info))
+                self._drive_service = build("drive", "v3", credentials=creds)
+        except Exception as e:
+            raise AirbyteTracedException(
+                internal_message=str(e),
+                message="Could not authenticate with Google Drive. Please check your credentials.",
+                failure_type=FailureType.config_error,
+                exception=e,
+            )
+
+        return self._drive_service
+
+    def get_matching_files(self, globs: List[str], prefix: Optional[str], logger: logging.Logger) -> Iterable[RemoteFile]:
+        """
+        Get all files matching the specified glob patterns.
+        """
+        service = self.google_drive_service
+        root_folder_id = get_folder_id(self.config.folder_url)
+        # ignore prefix argument as it's legacy only and this is a new connector
+        prefixes = self.get_prefixes_from_globs(globs)
+
+        folder_id_queue = [("", root_folder_id)]
+        seen: Set[str] = set()
+        while len(folder_id_queue) > 0:
+            (path, folder_id) = folder_id_queue.pop()
+            # fetch all files in this folder (1000 is the max page size)
+            # supportsAllDrives and includeItemsFromAllDrives are required to access files in shared drives
+            request = service.files().list(
+                q=f"'{folder_id}' in parents",
+                pageSize=1000,
+                fields="nextPageToken, files(id, name, modifiedTime, mimeType)",
+                supportsAllDrives=True,
+                includeItemsFromAllDrives=True,
+            )
+            while True:
+                results = request.execute()
+                new_files = results.get("files", [])
+                for new_file in new_files:
+                    # It's possible files and folders are linked up multiple times, this prevents us from getting stuck in a loop
+                    if new_file["id"] in seen:
+                        continue
+                    seen.add(new_file["id"])
+                    file_name = path + new_file["name"]
+                    if new_file["mimeType"] == FOLDER_MIME_TYPE:
+                        folder_name = f"{file_name}/"
+                        # check prefix matching in both directions to handle
+                        prefix_matches_folder_name = any(prefix.startswith(folder_name) for prefix in prefixes)
+                        folder_name_matches_prefix = any(folder_name.startswith(prefix) for prefix in prefixes)
+                        if prefix_matches_folder_name or folder_name_matches_prefix or len(prefixes) == 0:
+                            folder_id_queue.append((folder_name, new_file["id"]))
+                        continue
+                    else:
+                        last_modified = datetime.strptime(new_file["modifiedTime"], "%Y-%m-%dT%H:%M:%S.%fZ")
+                        original_mime_type = new_file["mimeType"]
+                        mime_type = (
+                            self._get_export_mime_type(original_mime_type)
+                            if self._is_exportable_document(original_mime_type)
+                            else original_mime_type
+                        )
+                        remote_file = GoogleDriveRemoteFile(
+                            uri=file_name,
+                            last_modified=last_modified,
+                            id=new_file["id"],
+                            original_mime_type=original_mime_type,
+                            mime_type=mime_type,
+                        )
+                        if self.file_matches_globs(remote_file, globs):
+                            yield remote_file
+                request = service.files().list_next(request, results)
+                if request is None:
+                    break
+
+    def _is_exportable_document(self, mime_type: str):
+        """
+        Returns true if the given file is a Google App document that can be exported.
+        """
+        return mime_type in EXPORTABLE_DOCUMENTS_MIME_TYPES
+
+    def open_file(self, file: GoogleDriveRemoteFile, mode: FileReadMode, encoding: Optional[str], logger: logging.Logger) -> IOBase:
+        if self._is_exportable_document(file.original_mime_type):
+            if mode == FileReadMode.READ:
+                raise ValueError(
+                    "Google Docs/Drawings/Presentations can only be processed using the document file type format. Please set the format accordingly or adjust the glob pattern."
+                )
+            request = self.google_drive_service.files().export_media(fileId=file.id, mimeType=file.mime_type)
+        else:
+            request = self.google_drive_service.files().get_media(fileId=file.id)
+        handle = io.BytesIO()
+        downloader = MediaIoBaseDownload(handle, request)
+        done = False
+        while done is False:
+            _, done = downloader.next_chunk()
+
+        handle.seek(0)
+
+        if mode == FileReadMode.READ_BINARY:
+            return handle
+        else:
+            # repack the bytes into a string with the right encoding
+            text_handle = io.StringIO(handle.read().decode(encoding or "utf-8"))
+            handle.close()
+            return text_handle
+
+    def _get_export_mime_type(self, original_mime_type: str):
+        """
+        Returns the mime type to export Google App documents as.
+
+        Google Docs are exported as Docx to preserve as much formatting as possible, everything else goes through PDF.
+        """
+        if original_mime_type.startswith(GOOGLE_DOC_MIME_TYPE):
+            return "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+        else:
+            return "application/pdf"

source_google_drive/utils.py

@@ -0,0 +1,21 @@
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+
+from urllib.parse import urlparse
+
+
+def get_folder_id(url_string: str) -> str:
+    """
+    Extract the folder ID from a Google Drive folder URL.
+
+    Takes the last path segment of the URL, which is the folder ID (ignoring trailing slashes and query parameters).
+    """
+    try:
+        parsed_url = urlparse(url_string)
+        if parsed_url.scheme != "https" or parsed_url.netloc != "drive.google.com":
+            raise ValueError("Folder URL has to be of the form https://drive.google.com/drive/folders/<folder_id>")
+        path_segments = list(filter(None, parsed_url.path.split("/")))
+        if path_segments[-2] != "folders" or len(path_segments) < 3:
+            raise ValueError("Folder URL has to be of the form https://drive.google.com/drive/folders/<folder_id>")
+        return path_segments[-1]
+    except Exception:
+        raise ValueError("Folder URL is invalid")