dagster-airbyte 0.27.10__py3-none-any.whl → 0.27.12__py3-none-any.whl

dagster_airbyte/__init__.py

@@ -2,6 +2,7 @@ from dagster_shared.libraries import DagsterLibraryRegistry
 
 from dagster_airbyte.components.workspace_component.component import (
     AirbyteCloudWorkspaceComponent as AirbyteCloudWorkspaceComponent,
+    AirbyteWorkspaceComponent as AirbyteWorkspaceComponent,
 )
 
 try:
@@ -29,8 +30,10 @@ from dagster_airbyte.resources import (
     AirbyteCloudResource as AirbyteCloudResource,
     AirbyteCloudWorkspace as AirbyteCloudWorkspace,
     AirbyteResource as AirbyteResource,
+    AirbyteWorkspace as AirbyteWorkspace,
     airbyte_cloud_resource as airbyte_cloud_resource,
     airbyte_resource as airbyte_resource,
+    load_airbyte_asset_specs as load_airbyte_asset_specs,
     load_airbyte_cloud_asset_specs as load_airbyte_cloud_asset_specs,
 )
 from dagster_airbyte.translator import (

dagster_airbyte/asset_decorator.py

@@ -1,10 +1,10 @@
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, Union
 
 from dagster import AssetsDefinition, multi_asset
 from dagster._annotations import beta
 from dagster._core.errors import DagsterInvariantViolationError
 
-from dagster_airbyte.resources import AirbyteCloudWorkspace
+from dagster_airbyte.resources import AirbyteCloudWorkspace, AirbyteWorkspace
 from dagster_airbyte.translator import AirbyteMetadataSet, DagsterAirbyteTranslator
 
 
@@ -12,7 +12,7 @@ from dagster_airbyte.translator import AirbyteMetadataSet, DagsterAirbyteTransla
 def airbyte_assets(
     *,
     connection_id: str,
-    workspace: AirbyteCloudWorkspace,
+    workspace: Union[AirbyteWorkspace, AirbyteCloudWorkspace],
     name: Optional[str] = None,
     group_name: Optional[str] = None,
     dagster_airbyte_translator: Optional[DagsterAirbyteTranslator] = None,
@@ -21,7 +21,7 @@ def airbyte_assets(
 
     Args:
         connection_id (str): The Airbyte Connection ID.
-        workspace (AirbyteCloudWorkspace): The Airbyte workspace to fetch assets from.
+        workspace (Union[AirbyteWorkspace, AirbyteCloudWorkspace]): The Airbyte workspace to fetch assets from.
         name (Optional[str], optional): The name of the op.
         group_name (Optional[str], optional): The name of the asset group.
         dagster_airbyte_translator (Optional[DagsterAirbyteTranslator], optional): The translator to use

dagster_airbyte/asset_defs.py

@@ -38,7 +38,9 @@ from dagster_airbyte.resources import (
     AirbyteCloudResource,
     AirbyteCloudWorkspace,
     AirbyteResource,
+    AirbyteWorkspace,
     BaseAirbyteResource,
+    BaseAirbyteWorkspace,
 )
 from dagster_airbyte.translator import (
     AirbyteConnection,
@@ -1040,14 +1042,14 @@ def load_assets_from_airbyte_instance(
 @beta
 def build_airbyte_assets_definitions(
     *,
-    workspace: AirbyteCloudWorkspace,
+    workspace: Union[AirbyteWorkspace, AirbyteCloudWorkspace],
     dagster_airbyte_translator: Optional[DagsterAirbyteTranslator] = None,
     connection_selector_fn: Optional[Callable[[AirbyteConnection], bool]] = None,
 ) -> Sequence[AssetsDefinition]:
     """The list of AssetsDefinition for all connections in the Airbyte workspace.
 
     Args:
-        workspace (AirbyteCloudWorkspace): The Airbyte workspace to fetch assets from.
+        workspace (Union[AirbyteWorkspace, AirbyteCloudWorkspace]): The Airbyte workspace to fetch assets from.
         dagster_airbyte_translator (Optional[DagsterAirbyteTranslator], optional): The translator to use
             to convert Airbyte content into :py:class:`dagster.AssetSpec`.
             Defaults to :py:class:`DagsterAirbyteTranslator`.
@@ -1164,7 +1166,7 @@ def build_airbyte_assets_definitions(
             name=f"airbyte_{clean_name(connection_name)}",
             dagster_airbyte_translator=dagster_airbyte_translator,
         )
-        def _asset_fn(context: AssetExecutionContext, airbyte: AirbyteCloudWorkspace):
+        def _asset_fn(context: AssetExecutionContext, airbyte: BaseAirbyteWorkspace):
             yield from airbyte.sync_and_poll(context=context)
 
         _asset_fns.append(_asset_fn)

dagster_airbyte/components/workspace_component/component.py

@@ -4,6 +4,7 @@ from typing import Annotated, Callable, Optional, Union
 
 import dagster as dg
 import pydantic
+from dagster._annotations import superseded
 from dagster._core.definitions.job_definition import default_job_io_manager
 from dagster.components.resolved.base import resolve_fields
 from dagster.components.utils.translation import TranslationFn, TranslationFnResolver
@@ -11,9 +12,9 @@ from dagster_shared import check
 
 from dagster_airbyte.asset_defs import build_airbyte_assets_definitions
 from dagster_airbyte.components.workspace_component.scaffolder import (
-    AirbyteCloudWorkspaceComponentScaffolder,
+    AirbyteWorkspaceComponentScaffolder,
 )
-from dagster_airbyte.resources import AirbyteCloudWorkspace
+from dagster_airbyte.resources import AirbyteCloudWorkspace, AirbyteWorkspace
 from dagster_airbyte.translator import (
     AirbyteConnection,
     AirbyteConnectionTableProps,
@@ -32,13 +33,100 @@ class ProxyDagsterAirbyteTranslator(DagsterAirbyteTranslator):
         return spec
 
 
-class AirbyteCloudWorkspaceModel(dg.Model):
-    workspace_id: Annotated[str, pydantic.Field(..., description="The Airbyte Cloud workspace ID.")]
+class BaseAirbyteWorkspaceModel(dg.Model, dg.Resolvable):
+    request_max_retries: Annotated[
+        int,
+        pydantic.Field(
+            default=3,
+            description=(
+                "The maximum number of times requests to the Airbyte API should be retried "
+                "before failing."
+            ),
+        ),
+    ]
+    request_retry_delay: Annotated[
+        float,
+        pydantic.Field(
+            default=0.25,
+            description="Time (in seconds) to wait between each request retry.",
+        ),
+    ]
+    request_timeout: Annotated[
+        int,
+        pydantic.Field(
+            default=15,
+            description="Time (in seconds) after which the requests to Airbyte are declared timed out.",
+        ),
+    ]
+
+
+class AirbyteWorkspaceModel(BaseAirbyteWorkspaceModel):
+    rest_api_base_url: Annotated[
+        str,
+        pydantic.Field(
+            ...,
+            description=(
+                "The base URL for the Airbyte REST API. "
+                "For Airbyte Cloud, leave this as the default. "
+                "For self-managed Airbyte, this is usually <your Airbyte host>/api/public/v1."
+            ),
+            examples=[
+                "http://localhost:8000/api/public/v1",
+                "https://my-airbyte-server.com/api/public/v1",
+                "http://airbyte-airbyte-server-svc.airbyte.svc.cluster.local:8001/api/public/v1",
+            ],
+        ),
+    ]
+    configuration_api_base_url: Annotated[
+        str,
+        pydantic.Field(
+            ...,
+            description=(
+                "The base URL for the Airbyte Configuration API. "
+                "For Airbyte Cloud, leave this as the default. "
+                "For self-managed Airbyte, this is usually <your Airbyte host>/api/v1."
+            ),
+            examples=[
+                "http://localhost:8000/api/v1",
+                "https://my-airbyte-server.com/api/v1",
+                "http://airbyte-airbyte-server-svc.airbyte.svc.cluster.local:8001/api/v1",
+            ],
+        ),
+    ]
+    workspace_id: Annotated[str, pydantic.Field(..., description="The Airbyte workspace ID.")]
+    client_id: Annotated[
+        Optional[str],
+        pydantic.Field(None, description="Client ID used to authenticate to Airbyte."),
+    ]
+    client_secret: Annotated[
+        Optional[str],
+        pydantic.Field(None, description="Client secret used to authenticate to Airbyte."),
+    ]
+    username: Annotated[
+        Optional[str],
+        pydantic.Field(
+            None,
+            description="Username used to authenticate to Airbyte. Used for self-managed Airbyte with basic auth.",
+        ),
+    ]
+    password: Annotated[
+        Optional[str],
+        pydantic.Field(
+            None,
+            description="Password used to authenticate to Airbyte. Used for self-managed Airbyte with basic auth.",
+        ),
+    ]
+
+
+class AirbyteCloudWorkspaceModel(BaseAirbyteWorkspaceModel):
+    workspace_id: Annotated[str, pydantic.Field(..., description="The Airbyte workspace ID.")]
     client_id: Annotated[
-        str, pydantic.Field(..., description="Client ID used to authenticate to Airbyte Cloud.")
+        Optional[str],
+        pydantic.Field(..., description="Client ID used to authenticate to Airbyte."),
     ]
     client_secret: Annotated[
-        str, pydantic.Field(..., description="Client secret used to authenticate to Airbyte Cloud.")
+        Optional[str],
+        pydantic.Field(..., description="Client secret used to authenticate to Airbyte."),
     ]
 
 
@@ -70,19 +158,27 @@ def resolve_connection_selector(
         check.failed(f"Unknown connection target type: {type(model)}")
 
 
-@dg.scaffold_with(AirbyteCloudWorkspaceComponentScaffolder)
-class AirbyteCloudWorkspaceComponent(dg.Component, dg.Model, dg.Resolvable):
-    """Loads Airbyte Cloud connections from a given Airbyte Cloud workspace as Dagster assets.
-    Materializing these assets will trigger a sync of the Airbyte Cloud connection, enabling
-    you to schedule Airbyte Cloud syncs using Dagster.
+def resolve_airbyte_workspace_type(context: dg.ResolutionContext, model):
+    if isinstance(model, AirbyteWorkspaceModel):
+        return AirbyteWorkspace(**resolve_fields(model, AirbyteWorkspaceModel, context))
+    elif isinstance(model, AirbyteCloudWorkspaceModel):
+        return AirbyteCloudWorkspace(**resolve_fields(model, AirbyteCloudWorkspaceModel, context))
+    else:
+        check.failed(f"Unknown Airbyte workspace type: {type(model)}")
+
+
+@dg.scaffold_with(AirbyteWorkspaceComponentScaffolder)
+class AirbyteWorkspaceComponent(dg.Component, dg.Model, dg.Resolvable):
+    """Loads Airbyte connections from a given Airbyte workspace as Dagster assets.
+    Materializing these assets will trigger a sync of the Airbyte connection, enabling
+    you to schedule Airbyte syncs using Dagster.
     """
 
     workspace: Annotated[
-        AirbyteCloudWorkspace,
+        Union[AirbyteWorkspace, AirbyteCloudWorkspace],
         dg.Resolver(
-            lambda context, model: AirbyteCloudWorkspace(
-                **resolve_fields(model, AirbyteCloudWorkspace, context)
-            )
+            resolve_airbyte_workspace_type,
+            model_field_type=Union[AirbyteWorkspaceModel, AirbyteCloudWorkspaceModel],
         ),
     ]
     connection_selector: Annotated[
@@ -92,7 +188,7 @@ class AirbyteCloudWorkspaceComponent(dg.Component, dg.Model, dg.Resolvable):
             model_field_type=Union[
                 str, AirbyteConnectionSelectorByName, AirbyteConnectionSelectorById
             ],
-            description="Function used to select Airbyte Cloud connections to pull into Dagster.",
+            description="Function used to select Airbyte connections to pull into Dagster.",
         ),
     ] = None
     translation: Optional[
@@ -102,13 +198,9 @@ class AirbyteCloudWorkspaceComponent(dg.Component, dg.Model, dg.Resolvable):
         ]
     ] = pydantic.Field(
         None,
-        description="Function used to translate Airbyte Cloud connection table properties into Dagster asset specs.",
+        description="Function used to translate Airbyte connection table properties into Dagster asset specs.",
     )
 
-    @cached_property
-    def workspace_resource(self) -> AirbyteCloudWorkspace:
-        return self.workspace
-
     @cached_property
     def translator(self) -> DagsterAirbyteTranslator:
         if self.translation:
@@ -117,17 +209,22 @@ class AirbyteCloudWorkspaceComponent(dg.Component, dg.Model, dg.Resolvable):
 
     def build_defs(self, context: dg.ComponentLoadContext) -> dg.Definitions:
         airbyte_assets = build_airbyte_assets_definitions(
-            workspace=self.workspace_resource,
+            workspace=self.workspace,
             dagster_airbyte_translator=self.translator,
             connection_selector_fn=self.connection_selector,
         )
         assets_with_resource = [
             airbyte_asset.with_resources(
                 {
-                    "airbyte": self.workspace_resource.get_resource_definition(),
+                    "airbyte": self.workspace.get_resource_definition(),
                     "io_manager": default_job_io_manager,
                 }
             )
             for airbyte_asset in airbyte_assets
         ]
         return dg.Definitions(assets=assets_with_resource)
+
+
+# Subclassing to create the alias to be able to use the superseded decorator.
+@superseded(additional_warn_text="Superseded. Use AirbyteWorkspaceComponent instead.")
+class AirbyteCloudWorkspaceComponent(AirbyteWorkspaceComponent): ...

dagster_airbyte/components/workspace_component/scaffolder.py

@@ -12,7 +12,7 @@ class AirbyteScaffolderParams(BaseModel):
     client_secret: Optional[str] = None
 
 
-class AirbyteCloudWorkspaceComponentScaffolder(Scaffolder[AirbyteScaffolderParams]):
+class AirbyteWorkspaceComponentScaffolder(Scaffolder[AirbyteScaffolderParams]):
     @classmethod
     def get_scaffold_params(cls) -> type[AirbyteScaffolderParams]:
         return AirbyteScaffolderParams

dagster_airbyte/resources.py

@@ -7,12 +7,14 @@ from abc import abstractmethod
 from collections.abc import Iterator, Mapping, Sequence
 from contextlib import contextmanager
 from datetime import datetime, timedelta
-from typing import Any, Callable, Optional, cast
+from typing import Any, Callable, ClassVar, Optional, Union, cast
+from urllib.parse import parse_qsl, urlparse
 
 import requests
 from dagster import (
     AssetExecutionContext,
     AssetMaterialization,
+    AssetSpec,
     ConfigurableResource,
     Definitions,
     Failure,
@@ -22,16 +24,16 @@ from dagster import (
     get_dagster_logger,
     resource,
 )
-from dagster._annotations import beta, public, superseded
+from dagster._annotations import superseded
 from dagster._config.pythonic_config import infer_schema_from_config_class
-from dagster._core.definitions.assets.definition.asset_spec import AssetSpec
 from dagster._core.definitions.definitions_load_context import StateBackedDefinitionsLoader
 from dagster._core.definitions.resource_definition import dagster_maintained_resource
-from dagster._record import record
-from dagster._utils.cached_method import cached_method
+from dagster._symbol_annotations import beta, public
 from dagster._utils.merger import deep_merge_dicts
 from dagster_shared.dagster_model import DagsterModel
-from pydantic import Field, PrivateAttr
+from dagster_shared.record import record
+from dagster_shared.utils.cached_method import cached_method
+from pydantic import Field, PrivateAttr, model_validator
 from requests.exceptions import RequestException
 
 from dagster_airbyte.translator import (
@@ -51,17 +53,20 @@ from dagster_airbyte.utils import (
     get_translator_from_airbyte_assets,
 )
 
-AIRBYTE_REST_API_BASE = "https://api.airbyte.com"
-AIRBYTE_REST_API_VERSION = "v1"
-
-AIRBYTE_CONFIGURATION_API_BASE = "https://cloud.airbyte.com/api"
-AIRBYTE_CONFIGURATION_API_VERSION = "v1"
+AIRBYTE_CLOUD_REST_API_BASE = "https://api.airbyte.com"
+AIRBYTE_CLOUD_REST_API_VERSION = "v1"
+AIRBYTE_CLOUD_REST_API_BASE_URL = f"{AIRBYTE_CLOUD_REST_API_BASE}/{AIRBYTE_CLOUD_REST_API_VERSION}"
+AIRBYTE_CLOUD_CONFIGURATION_API_BASE = "https://cloud.airbyte.com/api"
+AIRBYTE_CLOUD_CONFIGURATION_API_VERSION = "v1"
+AIRBYTE_CLOUD_CONFIGURATION_API_BASE_URL = (
+    f"{AIRBYTE_CLOUD_CONFIGURATION_API_BASE}/{AIRBYTE_CLOUD_CONFIGURATION_API_VERSION}"
+)
 
 DEFAULT_POLL_INTERVAL_SECONDS = 10
 
 # The access token expire every 3 minutes in Airbyte Cloud.
 # Refresh is needed after 2.5 minutes to avoid the "token expired" error message.
-AIRBYTE_CLOUD_REFRESH_TIMEDELTA_SECONDS = 150
+AIRBYTE_REFRESH_TIMEDELTA_SECONDS = 150
 
 AIRBYTE_RECONSTRUCTION_METADATA_KEY_PREFIX = "dagster-airbyte/reconstruction_metadata"
 
@@ -410,7 +415,7 @@ class AirbyteCloudResource(BaseAirbyteResource):
             or not self._access_token_timestamp
             or self._access_token_timestamp
             <= datetime.timestamp(
-                datetime.now() - timedelta(seconds=AIRBYTE_CLOUD_REFRESH_TIMEDELTA_SECONDS)
+                datetime.now() - timedelta(seconds=AIRBYTE_REFRESH_TIMEDELTA_SECONDS)
             )
         )
 
@@ -849,12 +854,36 @@ def airbyte_cloud_resource(context) -> AirbyteCloudResource:
 
 
 @beta
-class AirbyteCloudClient(DagsterModel):
-    """This class exposes methods on top of the Airbyte APIs for Airbyte Cloud."""
+class AirbyteClient(DagsterModel):
+    """This class exposes methods on top of the Airbyte APIs for Airbyte."""
 
+    rest_api_base_url: str = Field(
+        default=AIRBYTE_CLOUD_REST_API_BASE_URL,
+        description=(
+            "The base URL for the Airbyte REST API. "
+            "For Airbyte Cloud, leave this as the default. "
+            "For self-managed Airbyte, this is usually <your Airbyte host>/api/public/v1."
+        ),
+    )
+    configuration_api_base_url: str = Field(
+        default=AIRBYTE_CLOUD_CONFIGURATION_API_BASE_URL,
+        description=(
+            "The base URL for the Airbyte Configuration API. "
+            "For Airbyte Cloud, leave this as the default. "
+            "For self-managed Airbyte, this is usually <your Airbyte host>/api/v1."
+        ),
+    )
     workspace_id: str = Field(..., description="The Airbyte workspace ID")
-    client_id: str = Field(..., description="The Airbyte client ID.")
-    client_secret: str = Field(..., description="The Airbyte client secret.")
+    client_id: Optional[str] = Field(default=None, description="The Airbyte client ID.")
+    client_secret: Optional[str] = Field(default=None, description="The Airbyte client secret.")
+    username: Optional[str] = Field(
+        default=None,
+        description="The Airbyte username for authentication. Used for self-managed Airbyte with basic auth.",
+    )
+    password: Optional[str] = Field(
+        default=None,
+        description="The Airbyte password for authentication. Used for self-managed Airbyte with basic auth.",
+    )
     request_max_retries: int = Field(
         ...,
         description=(
@@ -874,19 +903,34 @@ class AirbyteCloudClient(DagsterModel):
     _access_token_value: Optional[str] = PrivateAttr(default=None)
     _access_token_timestamp: Optional[float] = PrivateAttr(default=None)
 
+    @model_validator(mode="before")
+    def validate_authentication(cls, values):
+        has_client_id = values.get("client_id") is not None
+        has_client_secret = values.get("client_secret") is not None
+        has_username = values.get("username") is not None
+        has_password = values.get("password") is not None
+
+        check.invariant(
+            has_username == has_password,
+            "Missing config: both username and password are required for Airbyte authentication.",
+        )
+
+        check.invariant(
+            has_client_id == has_client_secret,
+            "Missing config: both client_id and client_secret are required for Airbyte authentication.",
+        )
+
+        check.invariant(
+            not ((has_client_id or has_client_secret) and (has_username or has_password)),
+            "Invalid config: cannot provide both client_id/client_secret and username/password for Airbyte authentication.",
+        )
+        return values
+
     @property
     @cached_method
     def _log(self) -> logging.Logger:
         return get_dagster_logger()
 
-    @property
-    def rest_api_base_url(self) -> str:
-        return f"{AIRBYTE_REST_API_BASE}/{AIRBYTE_REST_API_VERSION}"
-
-    @property
-    def configuration_api_base_url(self) -> str:
-        return f"{AIRBYTE_CONFIGURATION_API_BASE}/{AIRBYTE_CONFIGURATION_API_VERSION}"
-
     @property
     def all_additional_request_params(self) -> Mapping[str, Any]:
         return {**self.authorization_request_params, **self.user_agent_request_params}
@@ -894,6 +938,9 @@ class AirbyteCloudClient(DagsterModel):
     @property
     def authorization_request_params(self) -> Mapping[str, Any]:
         # Make sure the access token is refreshed before using it when calling the API.
+        if not (self.client_id and self.client_secret):
+            return {}
+
         if self._needs_refreshed_access_token():
             self._refresh_access_token()
         return {
@@ -908,10 +955,9 @@ class AirbyteCloudClient(DagsterModel):
 
     def _refresh_access_token(self) -> None:
         response = check.not_none(
-            self._make_request(
+            self._single_request(
                 method="POST",
-                endpoint="applications/token",
-                base_url=self.rest_api_base_url,
+                url=f"{self.rest_api_base_url}/applications/token",
                 data={
                     "client_id": self.client_id,
                     "client_secret": self.client_secret,
@@ -928,9 +974,7 @@ class AirbyteCloudClient(DagsterModel):
             not self._access_token_value
             or not self._access_token_timestamp
             or self._access_token_timestamp
-            <= (
-                datetime.now() - timedelta(seconds=AIRBYTE_CLOUD_REFRESH_TIMEDELTA_SECONDS)
-            ).timestamp()
+            <= (datetime.now() - timedelta(seconds=AIRBYTE_REFRESH_TIMEDELTA_SECONDS)).timestamp()
         )
 
     def _get_session(self, include_additional_request_params: bool) -> requests.Session:
@@ -942,33 +986,21 @@ class AirbyteCloudClient(DagsterModel):
             }
         session = requests.Session()
         session.headers.update(headers)
+
+        if self.username and self.password:
+            session.auth = (self.username, self.password)
+
         return session
 
-    def _make_request(
+    def _single_request(
         self,
         method: str,
-        endpoint: str,
-        base_url: str,
+        url: str,
         data: Optional[Mapping[str, Any]] = None,
         params: Optional[Mapping[str, Any]] = None,
         include_additional_request_params: bool = True,
     ) -> Mapping[str, Any]:
-        """Creates and sends a request to the desired Airbyte REST API endpoint.
-
-        Args:
-            method (str): The http method to use for this request (e.g. "POST", "GET", "PATCH").
-            endpoint (str): The Airbyte API endpoint to send this request to.
-            base_url (str): The base url to the Airbyte API to use.
-            data (Optional[Dict[str, Any]]): JSON-formatted data string to be included in the request.
-            params (Optional[Dict[str, Any]]): JSON-formatted query params to be included in the request.
-            include_additional_request_params (bool): Whether to include authorization and user-agent headers
-            to the request parameters. Defaults to True.
-
-        Returns:
-            Dict[str, Any]: Parsed json data from the response to this request
-        """
-        url = f"{base_url}/{endpoint}"
-
+        """Execute a single HTTP request with retry logic."""
         num_retries = 0
         while True:
             try:
@@ -989,14 +1021,54 @@ class AirbyteCloudClient(DagsterModel):
                 num_retries += 1
                 time.sleep(self.request_retry_delay)
 
-        raise Failure(f"Max retries ({self.request_max_retries}) exceeded with url: {url}.")
+            raise Failure(f"Max retries ({self.request_max_retries}) exceeded with url: {url}.")
+
+        return {}
 
-    def get_connections(self) -> Mapping[str, Any]:
+    def _paginated_request(
+        self,
+        method: str,
+        url: str,
+        params: dict[str, Any],
+        data: Optional[Mapping[str, Any]] = None,
+        include_additional_request_params: bool = True,
+    ) -> Sequence[Mapping[str, Any]]:
+        """Execute paginated requests and yield all items."""
+        result_data = []
+        while True:
+            response = self._single_request(
+                method=method,
+                url=url,
+                data=data,
+                params=params,
+                include_additional_request_params=include_additional_request_params,
+            )
+
+            # Handle different response structures
+            result_data.extend(response.get("data", []))
+            next_url = response.get("next", "")
+            if not next_url:
+                break
+
+            # Parse the query string for the next page
+            next_params = parse_qsl(urlparse(next_url).query)
+            # Overwrite the pagination params with the ones for the next page
+            params.update(dict(next_params))
+
+        return result_data
+
+    def validate_workspace_id(self) -> None:
+        """Fetches workspace details. This is used to validate that the workspace exists."""
+        self._single_request(
+            method="GET",
+            url=f"{self.rest_api_base_url}/workspaces/{self.workspace_id}",
+        )
+
+    def get_connections(self) -> Sequence[Mapping[str, Any]]:
         """Fetches all connections of an Airbyte workspace from the Airbyte REST API."""
-        return self._make_request(
+        return self._paginated_request(
             method="GET",
-            endpoint="connections",
-            base_url=self.rest_api_base_url,
+            url=f"{self.rest_api_base_url}/connections",
             params={"workspaceIds": self.workspace_id},
         )
 
@@ -1007,26 +1079,23 @@ class AirbyteCloudClient(DagsterModel):
         # Using the Airbyte Configuration API to get the connection details, including streams and their configs.
         # https://airbyte-public-api-docs.s3.us-east-2.amazonaws.com/rapidoc-api-docs.html#post-/v1/connections/get
         # https://github.com/airbytehq/airbyte-platform/blob/v1.0.0/airbyte-api/server-api/src/main/openapi/config.yaml
-        return self._make_request(
+        return self._single_request(
             method="POST",
-            endpoint="connections/get",
-            base_url=self.configuration_api_base_url,
+            url=f"{self.configuration_api_base_url}/connections/get",
             data={"connectionId": connection_id},
         )
 
     def get_destination_details(self, destination_id: str) -> Mapping[str, Any]:
         """Fetches details about a given destination from the Airbyte REST API."""
-        return self._make_request(
+        return self._single_request(
             method="GET",
-            endpoint=f"destinations/{destination_id}",
-            base_url=self.rest_api_base_url,
+            url=f"{self.rest_api_base_url}/destinations/{destination_id}",
         )
 
     def start_sync_job(self, connection_id: str) -> Mapping[str, Any]:
-        return self._make_request(
+        return self._single_request(
             method="POST",
-            endpoint="jobs",
-            base_url=self.rest_api_base_url,
+            url=f"{self.rest_api_base_url}/jobs",
             data={
                 "connectionId": connection_id,
                 "jobType": "sync",
@@ -1034,13 +1103,15 @@ class AirbyteCloudClient(DagsterModel):
         )
 
     def get_job_details(self, job_id: int) -> Mapping[str, Any]:
-        return self._make_request(
-            method="GET", endpoint=f"jobs/{job_id}", base_url=self.rest_api_base_url
+        return self._single_request(
+            method="GET",
+            url=f"{self.rest_api_base_url}/jobs/{job_id}",
         )
 
     def cancel_job(self, job_id: int) -> Mapping[str, Any]:
-        return self._make_request(
-            method="DELETE", endpoint=f"jobs/{job_id}", base_url=self.rest_api_base_url
+        return self._single_request(
+            method="DELETE",
+            url=f"{self.rest_api_base_url}/jobs/{job_id}",
         )
 
     def sync_and_poll(
@@ -1119,14 +1190,11 @@ class AirbyteCloudClient(DagsterModel):
 
 
 @beta
-class AirbyteCloudWorkspace(ConfigurableResource):
-    """This class represents a Airbyte Cloud workspace and provides utilities
+class BaseAirbyteWorkspace(ConfigurableResource):
+    """This class represents a Airbyte workspace and provides utilities
     to interact with Airbyte APIs.
     """
 
-    workspace_id: str = Field(..., description="The Airbyte Cloud workspace ID")
-    client_id: str = Field(..., description="The Airbyte Cloud client ID.")
-    client_secret: str = Field(..., description="The Airbyte Cloud client secret.")
     request_max_retries: int = Field(
         default=3,
         description=(
@@ -1142,18 +1210,7 @@ class AirbyteCloudWorkspace(ConfigurableResource):
         default=15,
         description="Time (in seconds) after which the requests to Airbyte are declared timed out.",
     )
-    _client: AirbyteCloudClient = PrivateAttr(default=None)  # type: ignore
-
-    @cached_method
-    def get_client(self) -> AirbyteCloudClient:
-        return AirbyteCloudClient(
-            workspace_id=self.workspace_id,
-            client_id=self.client_id,
-            client_secret=self.client_secret,
-            request_max_retries=self.request_max_retries,
-            request_retry_delay=self.request_retry_delay,
-            request_timeout=self.request_timeout,
-        )
+    _client: AirbyteClient = PrivateAttr(default=None)  # type: ignore
 
     @cached_method
     def fetch_airbyte_workspace_data(
@@ -1168,7 +1225,10 @@ class AirbyteCloudWorkspace(ConfigurableResource):
         destinations_by_id = {}
 
         client = self.get_client()
-        connections = client.get_connections()["data"]
+
+        client.validate_workspace_id()
+
+        connections = client.get_connections()
 
         for partial_connection_details in connections:
             full_connection_details = client.get_connection_details(
@@ -1214,14 +1274,14 @@ class AirbyteCloudWorkspace(ConfigurableResource):
             Loading the asset specs for a given Airbyte workspace:
             .. code-block:: python
 
-                from dagster_airbyte import AirbyteCloudWorkspace
+                from dagster_airbyte import AirbyteWorkspace
 
                 import dagster as dg
 
-                airbyte_workspace = AirbyteCloudWorkspace(
-                    workspace_id=dg.EnvVar("AIRBYTE_CLOUD_WORKSPACE_ID"),
-                    client_id=dg.EnvVar("AIRBYTE_CLOUD_CLIENT_ID"),
-                    client_secret=dg.EnvVar("AIRBYTE_CLOUD_CLIENT_SECRET"),
+                airbyte_workspace = AirbyteWorkspace(
+                    workspace_id=dg.EnvVar("AIRBYTE_WORKSPACE_ID"),
+                    client_id=dg.EnvVar("AIRBYTE_CLIENT_ID"),
+                    client_secret=dg.EnvVar("AIRBYTE_CLIENT_SECRET"),
                 )
 
                 airbyte_specs = airbyte_workspace.load_asset_specs()
@@ -1229,7 +1289,7 @@ class AirbyteCloudWorkspace(ConfigurableResource):
         """
         dagster_airbyte_translator = dagster_airbyte_translator or DagsterAirbyteTranslator()
 
-        return load_airbyte_cloud_asset_specs(
+        return load_airbyte_asset_specs(
             workspace=self,
             dagster_airbyte_translator=dagster_airbyte_translator,
             connection_selector_fn=connection_selector_fn,
@@ -1267,7 +1327,7 @@ class AirbyteCloudWorkspace(ConfigurableResource):
                 yield AssetMaterialization(
                     asset_key=stream_asset_spec.key,
                     description=(
-                        f"Table generated via Airbyte Cloud sync "
+                        f"Table generated via Airbyte sync "
                         f"for connection {connection.name}: {connection_table_name}"
                     ),
                     metadata=stream_asset_spec.metadata,
@@ -1276,7 +1336,7 @@ class AirbyteCloudWorkspace(ConfigurableResource):
     @public
     @beta
     def sync_and_poll(self, context: AssetExecutionContext):
-        """Executes a sync and poll process to materialize Airbyte Cloud assets.
+        """Executes a sync and poll process to materialize Airbyte assets.
             This method can only be used in the context of an asset execution.
 
         Args:
@@ -1322,9 +1382,9 @@ class AirbyteCloudWorkspace(ConfigurableResource):
             context.log.warning(f"Assets were not materialized: {unmaterialized_asset_keys}")
 
     @contextmanager
-    def process_config_and_initialize_cm_cached(self) -> Iterator["AirbyteCloudWorkspace"]:
+    def process_config_and_initialize_cm_cached(self) -> Iterator["AirbyteWorkspace"]:
         # Hack to avoid reconstructing initialized copies of this resource, which invalidates
-        # @cached_method caches. This means that multiple calls to load_airbyte_cloud_asset_specs
+        # @cached_method caches. This means that multiple calls to load_airbyte_asset_specs
         # will not trigger multiple API calls to fetch the workspace data.
         # Bespoke impl since @cached_method doesn't play nice with iterators; it's exhausted after
         # the first call.
@@ -1338,6 +1398,247 @@ class AirbyteCloudWorkspace(ConfigurableResource):
 
 
 @beta
+class AirbyteWorkspace(BaseAirbyteWorkspace):
+    """This resource allows users to programatically interface with the Airbyte REST API to launch
+    syncs and monitor their progress for a given Airbyte workspace.
+
+    **Examples:**
+    Using OAuth client credentials:
+
+    .. code-block:: python
+
+        import dagster as dg
+        from dagster_airbyte import AirbyteWorkspace, build_airbyte_assets_definitions
+
+        airbyte_workspace = AirbyteWorkspace(
+            rest_api_base_url=dg.EnvVar("AIRBYTE_REST_API_BASE_URL"),
+            configuration_api_base_url=dg.EnvVar("AIRBYTE_CONFIGURATION_API_BASE_URL"),
+            workspace_id=dg.EnvVar("AIRBYTE_WORKSPACE_ID"),
+            client_id=dg.EnvVar("AIRBYTE_CLIENT_ID"),
+            client_secret=dg.EnvVar("AIRBYTE_CLIENT_SECRET"),
+        )
+
+        all_airbyte_assets = build_airbyte_assets_definitions(workspace=airbyte_workspace)
+
+        defs = dg.Definitions(
+            assets=all_airbyte_assets,
+            resources={"airbyte": airbyte_workspace},
+        )
+
+    Using basic Authentication:
+
+    .. code-block:: python
+
+        import dagster as dg
+        from dagster_airbyte import AirbyteWorkspace, build_airbyte_assets_definitions
+
+        airbyte_workspace = AirbyteWorkspace(
+            rest_api_base_url=dg.EnvVar("AIRBYTE_REST_API_BASE_URL"),
+            configuration_api_base_url=dg.EnvVar("AIRBYTE_CONFIGURATION_API_BASE_URL"),
+            workspace_id=dg.EnvVar("AIRBYTE_WORKSPACE_ID"),
+            username=dg.EnvVar("AIRBYTE_USERNAME"),
+            password=dg.EnvVar("AIRBYTE_PASSWORD"),
+        )
+
+        all_airbyte_assets = build_airbyte_assets_definitions(workspace=airbyte_workspace)
+
+        defs = dg.Definitions(
+            assets=all_airbyte_assets,
+            resources={"airbyte": airbyte_workspace},
+        )
+
+    Using no authentication:
+
+    .. code-block:: python
+
+        import dagster as dg
+        from dagster_airbyte import AirbyteWorkspace, build_airbyte_assets_definitions
+
+        airbyte_workspace = AirbyteWorkspace(
+            rest_api_base_url=dg.EnvVar("AIRBYTE_REST_API_BASE_URL"),
+            configuration_api_base_url=dg.EnvVar("AIRBYTE_CONFIGURATION_API_BASE_URL"),
+            workspace_id=dg.EnvVar("AIRBYTE_WORKSPACE_ID"),
+        )
+
+        all_airbyte_assets = build_airbyte_assets_definitions(workspace=airbyte_workspace)
+
+        defs = dg.Definitions(
+            assets=all_airbyte_assets,
+            resources={"airbyte": airbyte_workspace},
+        )
+    """
+
+    rest_api_base_url: str = Field(
+        ...,
+        description="The base URL for the Airbyte REST API.",
+        examples=[
+            "http://localhost:8000/api/public/v1",
+            "https://my-airbyte-server.com/api/public/v1",
+            "http://airbyte-airbyte-server-svc.airbyte.svc.cluster.local:8001/api/public/v1",
+        ],
+    )
+    configuration_api_base_url: str = Field(
+        ...,
+        description="The base URL for the Airbyte Configuration API.",
+        examples=[
+            "http://localhost:8000/api/v1",
+            "https://my-airbyte-server.com/api/v1",
+            "http://airbyte-airbyte-server-svc.airbyte.svc.cluster.local:8001/api/v1",
+        ],
+    )
+    workspace_id: str = Field(..., description="The Airbyte workspace ID")
+    client_id: Optional[str] = Field(default=None, description="The Airbyte client ID.")
+    client_secret: Optional[str] = Field(default=None, description="The Airbyte client secret.")
+    username: Optional[str] = Field(
+        default=None, description="The Airbyte username for authentication."
+    )
+    password: Optional[str] = Field(
+        default=None, description="The Airbyte password for authentication."
+    )
+
+    @cached_method
+    def get_client(self) -> AirbyteClient:
+        return AirbyteClient(
+            rest_api_base_url=self.rest_api_base_url,
+            configuration_api_base_url=self.configuration_api_base_url,
+            workspace_id=self.workspace_id,
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            username=self.username,
+            password=self.password,
+            request_max_retries=self.request_max_retries,
+            request_retry_delay=self.request_retry_delay,
+            request_timeout=self.request_timeout,
+        )
+
+
+@beta
+class AirbyteCloudWorkspace(BaseAirbyteWorkspace):
+    """This resource allows users to programatically interface with the Airbyte Cloud REST API to launch
+    syncs and monitor their progress for a given Airbyte Cloud workspace.
+
+    **Examples:**
+
+    .. code-block:: python
+
+        from dagster_airbyte import AirbyteCloudWorkspace, build_airbyte_assets_definitions
+
+        import dagster as dg
+
+        airbyte_workspace = AirbyteCloudWorkspace(
+            workspace_id=dg.EnvVar("AIRBYTE_CLOUD_WORKSPACE_ID"),
+            client_id=dg.EnvVar("AIRBYTE_CLOUD_CLIENT_ID"),
+            client_secret=dg.EnvVar("AIRBYTE_CLOUD_CLIENT_SECRET"),
+        )
+
+        all_airbyte_assets = build_airbyte_assets_definitions(workspace=airbyte_workspace)
+
+        defs = dg.Definitions(
+            assets=all_airbyte_assets,
+            resources={"airbyte": airbyte_workspace},
+        )
+    """
+
+    rest_api_base_url: ClassVar[str] = AIRBYTE_CLOUD_REST_API_BASE_URL
+    configuration_api_base_url: ClassVar[str] = AIRBYTE_CLOUD_CONFIGURATION_API_BASE_URL
+    workspace_id: str = Field(..., description="The Airbyte workspace ID")
+    client_id: str = Field(..., description="The Airbyte client ID.")
+    client_secret: str = Field(..., description="The Airbyte client secret.")
+
+    @cached_method
+    def get_client(self) -> AirbyteClient:
+        return AirbyteClient(
+            rest_api_base_url=self.rest_api_base_url,
+            configuration_api_base_url=self.configuration_api_base_url,
+            workspace_id=self.workspace_id,
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            request_max_retries=self.request_max_retries,
+            request_retry_delay=self.request_retry_delay,
+            request_timeout=self.request_timeout,
+        )
+
+
+@public
+@beta
+def load_airbyte_asset_specs(
+    workspace: BaseAirbyteWorkspace,
+    dagster_airbyte_translator: Optional[DagsterAirbyteTranslator] = None,
+    connection_selector_fn: Optional[Callable[[AirbyteConnection], bool]] = None,
+) -> Sequence[AssetSpec]:
+    """Returns a list of AssetSpecs representing the Airbyte content in the workspace.
+
+    Args:
+        workspace (BaseAirbyteWorkspace): The Airbyte workspace to fetch assets from.
+        dagster_airbyte_translator (Optional[DagsterAirbyteTranslator], optional): The translator to use
+            to convert Airbyte content into :py:class:`dagster.AssetSpec`.
+            Defaults to :py:class:`DagsterAirbyteTranslator`.
+        connection_selector_fn (Optional[Callable[[AirbyteConnection], bool]]): A function that allows for filtering
+            which Airbyte connection assets are created for.
+
+    Returns:
+        List[AssetSpec]: The set of assets representing the Airbyte content in the workspace.
+
+    Examples:
+        Loading the asset specs for a given Airbyte workspace:
+
+        .. code-block:: python
+
+            from dagster_airbyte import AirbyteWorkspace, load_airbyte_asset_specs
+
+            import dagster as dg
+
+            airbyte_workspace = AirbyteWorkspace(
+                workspace_id=dg.EnvVar("AIRBYTE_WORKSPACE_ID"),
+                client_id=dg.EnvVar("AIRBYTE_CLIENT_ID"),
+                client_secret=dg.EnvVar("AIRBYTE_CLIENT_SECRET"),
+            )
+
+            airbyte_specs = load_airbyte_asset_specs(airbyte_workspace)
+            dg.Definitions(assets=airbyte_specs)
+
+        Filter connections by name:
+
+        .. code-block:: python
+
+            from dagster_airbyte import AirbyteWorkspace, load_airbyte_asset_specs
+
+            import dagster as dg
+
+            airbyte_workspace = AirbyteWorkspace(
+                workspace_id=dg.EnvVar("AIRBYTE_WORKSPACE_ID"),
+                client_id=dg.EnvVar("AIRBYTE_CLIENT_ID"),
+                client_secret=dg.EnvVar("AIRBYTE_CLIENT_SECRET"),
+            )
+
+            airbyte_specs = load_airbyte_asset_specs(
+                workspace=airbyte_workspace,
+                connection_selector_fn=lambda connection: connection.name in ["connection1", "connection2"]
+            )
+            dg.Definitions(assets=airbyte_specs)
+    """
+    dagster_airbyte_translator = dagster_airbyte_translator or DagsterAirbyteTranslator()
+
+    with workspace.process_config_and_initialize_cm_cached() as initialized_workspace:
+        return [
+            spec.merge_attributes(
+                metadata={DAGSTER_AIRBYTE_TRANSLATOR_METADATA_KEY: dagster_airbyte_translator}
+            )
+            for spec in check.is_list(
+                AirbyteWorkspaceDefsLoader(
+                    workspace=initialized_workspace,
+                    translator=dagster_airbyte_translator,
+                    connection_selector_fn=connection_selector_fn,
+                )
+                .build_defs()
+                .assets,
+                AssetSpec,
+            )
+        ]
+
+
+@public
+@superseded(additional_warn_text="Use load_airbyte_asset_specs instead.")
 def load_airbyte_cloud_asset_specs(
     workspace: AirbyteCloudWorkspace,
     dagster_airbyte_translator: Optional[DagsterAirbyteTranslator] = None,
@@ -1394,29 +1695,16 @@ def load_airbyte_cloud_asset_specs(
             )
             dg.Definitions(assets=airbyte_cloud_specs)
     """
-    dagster_airbyte_translator = dagster_airbyte_translator or DagsterAirbyteTranslator()
-
-    with workspace.process_config_and_initialize_cm_cached() as initialized_workspace:
-        return [
-            spec.merge_attributes(
-                metadata={DAGSTER_AIRBYTE_TRANSLATOR_METADATA_KEY: dagster_airbyte_translator}
-            )
-            for spec in check.is_list(
-                AirbyteCloudWorkspaceDefsLoader(
-                    workspace=initialized_workspace,
-                    translator=dagster_airbyte_translator,
-                    connection_selector_fn=connection_selector_fn,
-                )
-                .build_defs()
-                .assets,
-                AssetSpec,
-            )
-        ]
+    return load_airbyte_asset_specs(
+        workspace=workspace,
+        dagster_airbyte_translator=dagster_airbyte_translator,
+        connection_selector_fn=connection_selector_fn,
+    )
 
 
 @record
-class AirbyteCloudWorkspaceDefsLoader(StateBackedDefinitionsLoader[AirbyteWorkspaceData]):
-    workspace: AirbyteCloudWorkspace
+class AirbyteWorkspaceDefsLoader(StateBackedDefinitionsLoader[AirbyteWorkspaceData]):
+    workspace: Union[AirbyteWorkspace, AirbyteCloudWorkspace]
     translator: DagsterAirbyteTranslator
     connection_selector_fn: Optional[Callable[[AirbyteConnection], bool]]
 

dagster_airbyte/utils.py

@@ -13,7 +13,7 @@ from dagster._utils.names import clean_name_lower
 from dagster_airbyte.types import AirbyteOutput
 
 if TYPE_CHECKING:
-    from dagster_airbyte import DagsterAirbyteTranslator
+    from dagster_airbyte.translator import DagsterAirbyteTranslator
 
 DAGSTER_AIRBYTE_TRANSLATOR_METADATA_KEY = "dagster-airbyte/dagster_airbyte_translator"
 

dagster_airbyte/version.py

@@ -1 +1 @@
-__version__ = "0.27.10"
+__version__ = "0.27.12"

{dagster_airbyte-0.27.10.dist-info → dagster_airbyte-0.27.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster-airbyte
-Version: 0.27.10
+Version: 0.27.12
 Summary: Package for integrating Airbyte with Dagster.
 Home-page: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-airbyte
 Author: Dagster Labs
@@ -15,13 +15,13 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9,<3.14
 License-File: LICENSE
-Requires-Dist: dagster==1.11.10
+Requires-Dist: dagster==1.11.12
 Requires-Dist: requests
 Provides-Extra: test
 Requires-Dist: requests-mock; extra == "test"
 Requires-Dist: flaky; extra == "test"
 Provides-Extra: managed
-Requires-Dist: dagster-managed-elements==0.27.10; extra == "managed"
+Requires-Dist: dagster-managed-elements==0.27.12; extra == "managed"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{dagster_airbyte-0.27.10.dist-info → dagster_airbyte-0.27.12.dist-info}/RECORD

@@ -1,27 +1,27 @@
-dagster_airbyte/__init__.py,sha256=hbVxc3kc9gslNvQXqCkkMeMXRk51tyUeHiRK1ozt6rg,1864
-dagster_airbyte/asset_decorator.py,sha256=U6pbeyjE0meeXHed7ZVhaRfAsvLwTvDB14BSyDUYHqY,4565
-dagster_airbyte/asset_defs.py,sha256=q1CYxpJQYkSg418zmtgT4if_mj5HWv7mT_0dwv8x_D4,51597
+dagster_airbyte/__init__.py,sha256=Bc3BuYTIcz5XU6NbKHqIemxgFSydLsqVLyLcx6K2pVA,2024
+dagster_airbyte/asset_decorator.py,sha256=ziG1U5qleIIR8xbYmoKSA00gLazbrd09FzcgmGdZmkY,4640
+dagster_airbyte/asset_defs.py,sha256=0lGOKSAlTxOYFonDsEI4FzuiVAViV8pr2Zgx3R8fAvQ,51694
 dagster_airbyte/cli.py,sha256=HErteP1MjfHozKKSrznh0yAreKETbXp5NDHzXGsdvvE,425
 dagster_airbyte/ops.py,sha256=oOEczVYpqVRTc1-0osfpR5FZbPjNJDYihgRjk_qtOQA,4229
 dagster_airbyte/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-dagster_airbyte/resources.py,sha256=b8IeclEinuMMEzTc3zi18GmPZ3PdsxVM3-m-P28fElY,56496
+dagster_airbyte/resources.py,sha256=AXN_mtNl_JKauoOY29wyuiv9jjAiCNF9M4baVCQPMYo,67193
 dagster_airbyte/translator.py,sha256=RY2LhGPACIfyd2zOSH1swdLz4koX6_bvclW-alS3Bic,7547
 dagster_airbyte/types.py,sha256=TYUjI3skjLYeANjesgJ-IAJNu8bAnL1ymsUfz5LsRTE,1565
-dagster_airbyte/utils.py,sha256=SupW5PLwzyZHWTHKe17vh2PlGdcRT7xbYbMCT-ubGDo,4081
-dagster_airbyte/version.py,sha256=rD44SY2JykCovkEGCFrgvbnJS6r4RHYfL0pbhlXrG1c,24
+dagster_airbyte/utils.py,sha256=wG9119kXi87JgcOjK7iNozr-svZocJBQYoHBMmnXZcE,4092
+dagster_airbyte/version.py,sha256=LsrV9vLeQGPkCzZUAe_cL-EObzt7m1nJHGhyU7GcAI0,24
 dagster_airbyte/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dagster_airbyte/components/workspace_component/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dagster_airbyte/components/workspace_component/component.py,sha256=sgj6s_xC5k-o72S5NhEFHGZ-b_0BKBw7Fzp4rY27phE,4954
-dagster_airbyte/components/workspace_component/scaffolder.py,sha256=4wMKNCsi8DBJ94jCKkofmqDW93u0UUCo8t0JYKZ10q4,1051
+dagster_airbyte/components/workspace_component/component.py,sha256=TIl8Ja6BHwpyRmkzkn-o75sH1dOUbbHtTftAb68Ag_c,8445
+dagster_airbyte/components/workspace_component/scaffolder.py,sha256=zk5HDJ6C8zcfUWKslJVyqyBB0LV3JzNAocY2ptT517s,1046
 dagster_airbyte/managed/__init__.py,sha256=6SBtyNOMJ9Cu2UIwFExJHpL_ZVFo3rPMvyIxVOsKvWE,469
 dagster_airbyte/managed/reconciliation.py,sha256=xoVfqPBpNSldkiqOLIPnc7ei8CppHKWtzv8bvxjdqlI,34859
 dagster_airbyte/managed/types.py,sha256=isPfX8L9YwtZAf9Vk4hhxBePLR00AEldsdK2TsM1H2o,14611
 dagster_airbyte/managed/generated/__init__.py,sha256=eYq-yfXEeffuKAVFXY8plD0se1wHjFNVqklpbu9gljw,108
 dagster_airbyte/managed/generated/destinations.py,sha256=x1wmWlXvOJHtfaZva3ErdKuVS--sDvfidSXR5ji9G5w,119692
 dagster_airbyte/managed/generated/sources.py,sha256=y0TPNvcRd8c9mhje-NoXsHeKRPt1nXcpww8mNAtqCps,282685
-dagster_airbyte-0.27.10.dist-info/licenses/LICENSE,sha256=4lsMW-RCvfVD4_F57wrmpe3vX1xwUk_OAKKmV_XT7Z0,11348
-dagster_airbyte-0.27.10.dist-info/METADATA,sha256=IduVeXSmqTgYyozKSAKz_2e9KC3gHRTx0k9a_1-98v0,1169
-dagster_airbyte-0.27.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dagster_airbyte-0.27.10.dist-info/entry_points.txt,sha256=096yvfMP-gNsCgDg9vDQtinis5QGpD-e_kHEhcHaML8,120
-dagster_airbyte-0.27.10.dist-info/top_level.txt,sha256=HLwIRQCzqItn88_KbPP8DNTKKQEBUVKk6NCn4PrCtqY,16
-dagster_airbyte-0.27.10.dist-info/RECORD,,
+dagster_airbyte-0.27.12.dist-info/licenses/LICENSE,sha256=4lsMW-RCvfVD4_F57wrmpe3vX1xwUk_OAKKmV_XT7Z0,11348
+dagster_airbyte-0.27.12.dist-info/METADATA,sha256=EqAF0V1BTHFPRJn3dL8OLbZen9irkb8W1IpWKmno2Sw,1169
+dagster_airbyte-0.27.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dagster_airbyte-0.27.12.dist-info/entry_points.txt,sha256=096yvfMP-gNsCgDg9vDQtinis5QGpD-e_kHEhcHaML8,120
+dagster_airbyte-0.27.12.dist-info/top_level.txt,sha256=HLwIRQCzqItn88_KbPP8DNTKKQEBUVKk6NCn4PrCtqY,16
+dagster_airbyte-0.27.12.dist-info/RECORD,,