airbyte-source-azure-blob-storage 0.8.6__py3-none-any.whl

airbyte_source_azure_blob_storage-0.8.6.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.1
+Name: airbyte-source-azure-blob-storage
+Version: 0.8.6
+Summary: Source implementation for Azure Blob Storage.
+Home-page: https://airbyte.com
+License: ELv2
+Author: Airbyte
+Author-email: contact@airbyte.io
+Requires-Python: >=3.11,<3.14
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: airbyte-cdk[file-based] (>=7.0.0,<8.0.0)
+Requires-Dist: pytz (>=2024.1,<2025.0)
+Requires-Dist: smart-open[azure] (==0.8.6)
+Project-URL: Documentation, https://docs.airbyte.com/integrations/sources/azure-blob-storage
+Project-URL: Repository, https://github.com/airbytehq/airbyte
+Description-Content-Type: text/markdown
+
+# Azure-Blob-Storage source connector
+
+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).
+
+## Local development
+
+### Prerequisites
+
+- Python (~=3.9)
+- Poetry (~=1.7) - installation instructions [here](https://python-poetry.org/docs/#installation)
+
+### Generate new oauth token
+
+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>
+
+### Installing the connector
+
+From this connector directory, run:
+
+```bash
+poetry install --with dev
+```
+
+### Create credentials
+
+**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.
+
+### Locally running the connector
+
+```
+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
+```
+
+### Running unit tests
+
+To run unit tests locally, from the connector directory run:
+
+```
+poetry run pytest unit_tests
+```
+
+### Building the docker image
+
+1. Install [`airbyte-ci`](https://github.com/airbytehq/airbyte/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`.
+
+### Running as a docker container
+
+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
+```
+
+### Running our CI test suite
+
+You can run our full test 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
+```
+
+### Customizing acceptance Tests
+
+Customize `acceptance-test-config.yml` file to configure acceptance tests. See [Connector Acceptance Tests](https://docs.airbyte.com/connector-development/testing-connectors/connector-acceptance-tests-reference) for more information.
+If your connector requires to create or destroy resources for use during acceptance tests create fixtures for it and place them inside integration_tests/acceptance.py.
+
+### Dependency Management
+
+All of your dependencies should be managed via Poetry.
+To add a new dependency, run:
+
+```bash
+poetry add <package-name>
+```
+
+Please commit the changes to `pyproject.toml` and `poetry.lock` files.
+
+## Publishing a new version of the connector
+
+You've checked out the repo, implemented a million dollar feature, and you're ready 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.
+

airbyte_source_azure_blob_storage-0.8.6.dist-info/RECORD

@@ -0,0 +1,10 @@
+source_azure_blob_storage/__init__.py,sha256=Wx4PzvHg900-c2CpOOP1Wk0zcJpNVqJrkMnPtDcuaQM,319
+source_azure_blob_storage/config_migrations.py,sha256=b0_UyUj1F4q_wPCxBpu4W8MxfMiHE2OvesXxks1bL2M,4331
+source_azure_blob_storage/run.py,sha256=4FImO8txeARJAE-c-glw5xxnDuiRT-XSLYKFVBn70tI,2206
+source_azure_blob_storage/source.py,sha256=ZubuoAmy_QxRtJIJVSugmBoMxw3dMjLTSAIXbZf3jjE,2493
+source_azure_blob_storage/spec.py,sha256=tRiF9KacJFK97HaleJucQadR4e2hjnmStJnbLEFV4vc,5043
+source_azure_blob_storage/stream_reader.py,sha256=YWzmk1mPqSy8H8gWRBYZc7F7-vBDqlNH3WrhVFCmAmk,7978
+airbyte_source_azure_blob_storage-0.8.6.dist-info/METADATA,sha256=75I_9BSoZ-Pl7N_gSWL9pYCImT5rz8wJIFku9Eijd7s,6282
+airbyte_source_azure_blob_storage-0.8.6.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+airbyte_source_azure_blob_storage-0.8.6.dist-info/entry_points.txt,sha256=75v_DA_Xu0qr0eqtEXyh8sPCqcL9eXKWY8UwdST3ANE,79
+airbyte_source_azure_blob_storage-0.8.6.dist-info/RECORD,,

airbyte_source_azure_blob_storage-0.8.6.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.1
+Root-Is-Purelib: true
+Tag: py3-none-any

airbyte_source_azure_blob_storage-0.8.6.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+source-azure-blob-storage=source_azure_blob_storage.run:run
+

source_azure_blob_storage/__init__.py

@@ -0,0 +1,10 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+
+from .source import SourceAzureBlobStorage
+from .spec import SourceAzureBlobStorageSpec
+from .stream_reader import SourceAzureBlobStorageStreamReader
+
+__all__ = ["SourceAzureBlobStorage", "SourceAzureBlobStorageStreamReader", "SourceAzureBlobStorageSpec"]

source_azure_blob_storage/config_migrations.py

@@ -0,0 +1,119 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, List, Mapping
+
+import orjson
+
+from airbyte_cdk import AirbyteEntrypoint, Source, create_connector_config_control_message
+from airbyte_cdk.models import AirbyteMessageSerializer
+
+
+logger = logging.getLogger("airbyte_logger")
+
+
+class MigrateConfig(ABC):
+    @classmethod
+    @abstractmethod
+    def should_migrate(cls, config: Mapping[str, Any]) -> bool: ...
+
+    @classmethod
+    @abstractmethod
+    def migrate_config(cls, config: Mapping[str, Any]) -> Mapping[str, Any]: ...
+
+    @classmethod
+    def modify_and_save(cls, config_path: str, source: Source, config: Mapping[str, Any]) -> Mapping[str, Any]:
+        """
+        Modifies the configuration and then saves it back to the source.
+
+        Args:
+        - config_path (str): The path where the configuration is stored.
+        - source (Source): The data source.
+        - config (Mapping[str, Any]): The current configuration.
+
+        Returns:
+        - Mapping[str, Any]: The updated configuration.
+        """
+        migrated_config = cls.migrate_config(config)
+        source.write_config(migrated_config, config_path)
+        return migrated_config
+
+    @classmethod
+    def emit_control_message(cls, migrated_config: Mapping[str, Any]) -> None:
+        """
+        Emits the control messages related to configuration migration.
+
+        Args:
+        - migrated_config (Mapping[str, Any]): The migrated configuration.
+        """
+        print((orjson.dumps(AirbyteMessageSerializer.dump(create_connector_config_control_message(migrated_config))).decode()))
+
+    @classmethod
+    def migrate(cls, args: List[str], source: Source) -> None:
+        """
+        Orchestrates the configuration migration process.
+
+        It first checks if the `--config` argument is provided, and if so,
+        determines whether migration is needed, and then performs the migration
+        if required.
+
+        Args:
+        - args (List[str]): List of command-line arguments.
+        - source (Source): The data source.
+        """
+        config_path = AirbyteEntrypoint(source).extract_config(args)
+        if config_path:
+            config = source.read_config(config_path)
+            if cls.should_migrate(config):
+                cls.emit_control_message(cls.modify_and_save(config_path, source, config))
+
+
+class MigrateLegacyConfig(MigrateConfig):
+    """
+    Class that takes in Azure Blob Storage source configs in the legacy format and transforms them into
+    configs that can be used by the new Azure Blob Storage source built with the file-based CDK.
+    """
+
+    @classmethod
+    def should_migrate(cls, config: Mapping[str, Any]) -> bool:
+        return "streams" not in config
+
+    @classmethod
+    def migrate_config(cls, legacy_config: Mapping[str, Any]) -> Mapping[str, Any]:
+        azure_blob_storage_blobs_prefix = legacy_config.get("azure_blob_storage_blobs_prefix", "")
+        return {
+            "azure_blob_storage_endpoint": legacy_config.get("azure_blob_storage_endpoint", None),
+            "azure_blob_storage_account_name": legacy_config["azure_blob_storage_account_name"],
+            "azure_blob_storage_account_key": legacy_config["azure_blob_storage_account_key"],
+            "azure_blob_storage_container_name": legacy_config["azure_blob_storage_container_name"],
+            "streams": [
+                {
+                    "name": legacy_config["azure_blob_storage_container_name"],
+                    "legacy_prefix": azure_blob_storage_blobs_prefix,
+                    "validation_policy": "Emit Record",
+                    "format": {"filetype": "jsonl"},
+                }
+            ],
+        }
+
+
+class MigrateCredentials(MigrateConfig):
+    """
+    This class stands for migrating the config azure_blob_storage_account_key inside object `credentials`
+    """
+
+    @classmethod
+    def should_migrate(cls, config: Mapping[str, Any]) -> bool:
+        return "credentials" not in config
+
+    @classmethod
+    def migrate_config(cls, config: Mapping[str, Any]) -> Mapping[str, Any]:
+        config["credentials"] = {
+            "auth_type": "storage_account_key",
+            "azure_blob_storage_account_key": config.pop("azure_blob_storage_account_key"),
+        }
+        return config

source_azure_blob_storage/run.py

@@ -0,0 +1,54 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+
+import sys
+import time
+import traceback
+
+import orjson
+
+from airbyte_cdk import AirbyteEntrypoint, AirbyteMessage, Type, launch
+from airbyte_cdk.models import AirbyteErrorTraceMessage, AirbyteMessageSerializer, AirbyteTraceMessage, TraceType
+from airbyte_cdk.sources.file_based.stream.cursor import DefaultFileBasedCursor
+from source_azure_blob_storage import SourceAzureBlobStorage, SourceAzureBlobStorageSpec, SourceAzureBlobStorageStreamReader
+from source_azure_blob_storage.config_migrations import MigrateCredentials, MigrateLegacyConfig
+
+
+def run():
+    args = sys.argv[1:]
+    catalog_path = AirbyteEntrypoint.extract_catalog(args)
+    config_path = AirbyteEntrypoint.extract_config(args)
+    state_path = AirbyteEntrypoint.extract_state(args)
+    try:
+        source = SourceAzureBlobStorage(
+            SourceAzureBlobStorageStreamReader(),
+            SourceAzureBlobStorageSpec,
+            SourceAzureBlobStorage.read_catalog(catalog_path) if catalog_path else None,
+            SourceAzureBlobStorage.read_config(config_path) if catalog_path else None,
+            SourceAzureBlobStorage.read_state(state_path) if catalog_path else None,
+            cursor_cls=DefaultFileBasedCursor,
+        )
+        MigrateLegacyConfig.migrate(sys.argv[1:], source)
+        MigrateCredentials.migrate(sys.argv[1:], source)
+    except Exception:
+        print(
+            orjson.dumps(
+                AirbyteMessageSerializer.dump(
+                    AirbyteMessage(
+                        type=Type.TRACE,
+                        trace=AirbyteTraceMessage(
+                            type=TraceType.ERROR,
+                            emitted_at=time.time_ns() // 1_000_000,
+                            error=AirbyteErrorTraceMessage(
+                                message="Error starting the sync. This could be due to an invalid configuration or catalog. Please contact Support for assistance.",
+                                stack_trace=traceback.format_exc(),
+                            ),
+                        ),
+                    )
+                )
+            ).decode()
+        )
+    else:
+        launch(source, args)

source_azure_blob_storage/source.py

@@ -0,0 +1,53 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+
+from typing import Any
+
+from airbyte_protocol_dataclasses.models import AuthFlowType
+
+from airbyte_cdk import AdvancedAuth, ConnectorSpecification, OAuthConfigSpecification
+from airbyte_cdk.sources.file_based.file_based_source import FileBasedSource
+
+
+class SourceAzureBlobStorage(FileBasedSource):
+    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=AuthFlowType.oauth2_0,
+                predicate_key=["credentials", "auth_type"],
+                predicate_value="oauth2",
+                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"]},
+                        },
+                    },
+                    oauth_user_input_from_connector_config_specification={
+                        "type": "object",
+                        "additionalProperties": False,
+                        "properties": {"tenant_id": {"type": "string", "path_in_connector_config": ["credentials", "tenant_id"]}},
+                    },
+                ),
+            ),
+        )

source_azure_blob_storage/spec.py

@@ -0,0 +1,132 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+
+from typing import Any, Dict, Literal, Optional, Union
+
+import dpath.util
+from pydantic.v1 import AnyUrl, BaseModel, Field
+
+from airbyte_cdk import OneOfOptionConfig
+from airbyte_cdk.sources.file_based.config.abstract_file_based_spec import AbstractFileBasedSpec, DeliverRawFiles, DeliverRecords
+
+
+class Oauth2(BaseModel):
+    class Config(OneOfOptionConfig):
+        title = "Authenticate via Oauth2"
+        discriminator = "auth_type"
+
+    auth_type: Literal["oauth2"] = Field("oauth2", const=True)
+    tenant_id: str = Field(title="Tenant ID", description="Tenant ID of the Microsoft Azure Application user", airbyte_secret=True)
+    client_id: str = Field(
+        title="Client ID",
+        description="Client ID of your Microsoft developer application",
+        airbyte_secret=True,
+    )
+    client_secret: str = Field(
+        title="Client Secret",
+        description="Client Secret of your Microsoft developer application",
+        airbyte_secret=True,
+    )
+    refresh_token: str = Field(
+        title="Refresh Token",
+        description="Refresh Token of your Microsoft developer application",
+        airbyte_secret=True,
+    )
+
+
+class ClientCredentials(BaseModel):
+    class Config(OneOfOptionConfig):
+        title = "Authenticate via Client Credentials"
+        discriminator = "auth_type"
+
+    auth_type: Literal["client_credentials"] = Field("client_credentials", const=True)
+    app_tenant_id: str = Field(title="Tenant ID", description="Tenant ID of the Microsoft Azure Application", airbyte_secret=True)
+    app_client_id: str = Field(
+        title="Client ID",
+        description="Client ID of your Microsoft developer application",
+        airbyte_secret=True,
+    )
+    app_client_secret: str = Field(
+        title="Client Secret",
+        description="Client Secret of your Microsoft developer application",
+        airbyte_secret=True,
+    )
+
+
+class StorageAccountKey(BaseModel):
+    class Config(OneOfOptionConfig):
+        title = "Authenticate via Storage Account Key"
+        discriminator = "auth_type"
+
+    auth_type: Literal["storage_account_key"] = Field("storage_account_key", const=True)
+    azure_blob_storage_account_key: str = Field(
+        title="Azure Blob Storage account key",
+        description="The Azure blob storage account key.",
+        airbyte_secret=True,
+        examples=["Z8ZkZpteggFx394vm+PJHnGTvdRncaYS+JhLKdj789YNmD+iyGTnG+PV+POiuYNhBg/ACS+LKjd%4FG3FHGN12Nd=="],
+        order=3,
+    )
+
+
+class SourceAzureBlobStorageSpec(AbstractFileBasedSpec):
+    """
+    NOTE: When this Spec is changed, legacy_config_transformer.py must also be modified to uptake the changes
+    because it is responsible for converting legacy Azure Blob Storage v0 configs into v1 configs using the File-Based CDK.
+    """
+
+    @classmethod
+    def documentation_url(cls) -> AnyUrl:
+        return AnyUrl("https://docs.airbyte.com/integrations/sources/azure-blob-storage", scheme="https")
+
+    credentials: Union[Oauth2, ClientCredentials, StorageAccountKey] = Field(
+        title="Authentication",
+        description="Credentials for connecting to the Azure Blob Storage",
+        discriminator="auth_type",
+        type="object",
+        order=2,
+    )
+    azure_blob_storage_account_name: str = Field(
+        title="Azure Blob Storage account name",
+        description="The account's name of the Azure Blob Storage.",
+        examples=["airbyte5storage"],
+        order=3,
+    )
+    azure_blob_storage_container_name: str = Field(
+        title="Azure blob storage container (Bucket) Name",
+        description="The name of the Azure blob storage container.",
+        examples=["airbytetescontainername"],
+        order=4,
+    )
+    azure_blob_storage_endpoint: Optional[str] = Field(
+        title="Endpoint Domain Name",
+        description="This is Azure Blob Storage endpoint domain name. Leave default value (or leave it empty if run container from "
+        "command line) to use Microsoft native from example.",
+        examples=["blob.core.windows.net"],
+        order=11,
+    )
+
+    delivery_method: Union[DeliverRecords, DeliverRawFiles] = Field(
+        title="Delivery Method",
+        discriminator="delivery_type",
+        type="object",
+        order=7,
+        display_type="radio",
+        group="advanced",
+        default="use_records_transfer",
+        airbyte_hidden=True,
+    )
+
+    @classmethod
+    def schema(cls, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Generates the mapping comprised of the config fields
+        """
+        schema = super().schema(*args, **kwargs)
+
+        # 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_azure_blob_storage/stream_reader.py

@@ -0,0 +1,183 @@
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+
+
+import logging
+from io import IOBase
+from typing import Any, Iterable, List, Mapping, MutableMapping, Optional, Union
+
+import pytz
+from azure.core.credentials import AccessToken, TokenCredential
+from azure.core.exceptions import ResourceNotFoundError
+from azure.storage.blob import BlobServiceClient, ContainerClient
+from smart_open import open as so_open
+
+from airbyte_cdk import AirbyteTracedException, FailureType
+from airbyte_cdk.sources.file_based.file_based_stream_reader import AbstractFileBasedStreamReader, FileReadMode
+from airbyte_cdk.sources.file_based.remote_file import UploadableRemoteFile
+from airbyte_cdk.sources.streams.http.requests_native_auth import Oauth2Authenticator
+
+from .spec import SourceAzureBlobStorageSpec
+
+
+class AzureClientCredentialsAuthenticator(Oauth2Authenticator, TokenCredential):
+    def __init__(self, tenant_id: str, client_id: str, client_secret: str, **kwargs):
+        super().__init__(
+            token_refresh_endpoint=f"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token",
+            client_id=client_id,
+            client_secret=client_secret,
+            grant_type="client_credentials",
+            scopes=["https://storage.azure.com/.default"],
+            refresh_token=None,
+        )
+
+    def build_refresh_request_body(self) -> Mapping[str, Any]:
+        """
+        Returns the request body to set on the refresh request
+
+        Override to define additional parameters
+        """
+        payload: MutableMapping[str, Any] = {
+            "grant_type": self.get_grant_type(),
+            "client_id": self.get_client_id(),
+            "client_secret": self.get_client_secret(),
+        }
+
+        if self.get_scopes():
+            payload["scope"] = " ".join(self.get_scopes())
+
+        if self.get_refresh_request_body():
+            for key, val in self.get_refresh_request_body().items():
+                # We defer to existing oauth constructs over custom configured fields
+                if key not in payload:
+                    payload[key] = val
+
+        return payload
+
+    def get_token(self, *args, **kwargs) -> AccessToken:
+        """Parent class handles Oauth Refresh token logic."""
+        return AccessToken(token=self.get_access_token(), expires_on=int(self.get_token_expiry_date().timestamp()))
+
+
+class AzureOauth2Authenticator(Oauth2Authenticator, TokenCredential):
+    """
+    Authenticator for Azure Blob Storage SDK to align with azure.core.credentials.TokenCredential protocol
+    """
+
+    def get_token(self, *args, **kwargs) -> AccessToken:
+        """Parent class handles Oauth Refresh token logic.
+        `expires_on` is ignored and set to year 2222 to align with protocol.
+        """
+        return AccessToken(token=self.get_access_token(), expires_on=7952342400)
+
+
+class AzureBlobStorageUploadableRemoteFile(UploadableRemoteFile):
+    blob_client: Any
+    blob_properties: Any
+
+    def __init__(self, blob_client: Any, blob_properties: Any, **kwargs):
+        super().__init__(**kwargs)
+        self.blob_client = blob_client
+        self.blob_properties = blob_properties
+
+    @property
+    def size(self) -> int:
+        return self.blob_properties.size
+
+    def download_to_local_directory(self, local_file_path: str) -> None:
+        blob_client = self.blob_client.get_blob_client(container=self.blob_properties.container, blob=self.uri)
+        with open(file=local_file_path, mode="wb") as f:
+            download_stream = blob_client.download_blob()
+            f.write(download_stream.readall())
+
+
+class SourceAzureBlobStorageStreamReader(AbstractFileBasedStreamReader):
+    _credentials = None
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._config = None
+
+    @property
+    def config(self) -> SourceAzureBlobStorageSpec:
+        return self._config
+
+    @config.setter
+    def config(self, value: SourceAzureBlobStorageSpec) -> None:
+        self._config = value
+
+    @property
+    def account_url(self) -> str:
+        if not self.config.azure_blob_storage_endpoint:
+            return f"https://{self.config.azure_blob_storage_account_name}.blob.core.windows.net"
+        return self.config.azure_blob_storage_endpoint
+
+    @property
+    def azure_container_client(self):
+        return ContainerClient(
+            self.account_url, container_name=self.config.azure_blob_storage_container_name, credential=self.azure_credentials
+        )
+
+    @property
+    def azure_blob_service_client(self):
+        return BlobServiceClient(self.account_url, credential=self._credentials)
+
+    @property
+    def azure_credentials(self) -> Union[str, AzureOauth2Authenticator, AzureClientCredentialsAuthenticator]:
+        if not self._credentials:
+            if self.config.credentials.auth_type == "storage_account_key":
+                self._credentials = self.config.credentials.azure_blob_storage_account_key
+            elif self.config.credentials.auth_type == "oauth2":
+                self._credentials = AzureOauth2Authenticator(
+                    token_refresh_endpoint=f"https://login.microsoftonline.com/{self.config.credentials.tenant_id}/oauth2/v2.0/token",
+                    client_id=self.config.credentials.client_id,
+                    client_secret=self.config.credentials.client_secret,
+                    refresh_token=self.config.credentials.refresh_token,
+                )
+            elif self.config.credentials.auth_type == "client_credentials":
+                self._credentials = AzureClientCredentialsAuthenticator(
+                    tenant_id=self.config.credentials.app_tenant_id,
+                    client_id=self.config.credentials.app_client_id,
+                    client_secret=self.config.credentials.app_client_secret,
+                )
+
+        return self._credentials
+
+    def get_matching_files(
+        self,
+        globs: List[str],
+        prefix: Optional[str],
+        logger: logging.Logger,
+    ) -> Iterable[AzureBlobStorageUploadableRemoteFile]:
+        prefixes = [prefix] if prefix else self.get_prefixes_from_globs(globs)
+        prefixes = prefixes or [None]
+        try:
+            for prefix in prefixes:
+                for blob in self.azure_container_client.list_blobs(name_starts_with=prefix):
+                    remote_file = AzureBlobStorageUploadableRemoteFile(
+                        uri=blob.name,
+                        last_modified=blob.last_modified.astimezone(pytz.utc).replace(tzinfo=None),
+                        blob_client=self.azure_blob_service_client,
+                        blob_properties=blob,
+                        created_at=blob.creation_time.astimezone(pytz.utc).replace(tzinfo=None).strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+                        updated_at=blob.last_modified.astimezone(pytz.utc).replace(tzinfo=None).strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+                    )
+                    yield from self.filter_files_by_globs_and_start_date([remote_file], globs)
+        except ResourceNotFoundError as e:
+            raise AirbyteTracedException(failure_type=FailureType.config_error, internal_message=e.message, message=e.reason or e.message)
+
+    def open_file(
+        self, file: AzureBlobStorageUploadableRemoteFile, mode: FileReadMode, encoding: Optional[str], logger: logging.Logger
+    ) -> IOBase:
+        try:
+            result = so_open(
+                f"azure://{self.config.azure_blob_storage_container_name}/{file.uri}",
+                transport_params={"client": self.azure_blob_service_client},
+                mode=mode.value,
+                encoding=encoding,
+            )
+        except OSError:
+            logger.warning(
+                f"We don't have access to {file.uri}. The file appears to have become unreachable during sync."
+                f"Check whether key {file.uri} exists in `{self.config.azure_blob_storage_container_name}` container and/or has proper ACL permissions"
+            )
+        return result