acceldata-sdk-python 26.7.0__py3-none-any.whl

acceldata/models/sdk/catalog/asset_resource.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from acceldata.models.api.catalog.asset import Asset
+from acceldata.models.api.catalog.asset_label_request import AssetLabelRequest
+from acceldata.models.api.catalog.asset_tag_info import AssetTagInfo
+from acceldata.models.api.catalog.asset_tag_request import AssetTagRequest
+from acceldata.models.api.catalog.catalog_asset_meta_data import CatalogAssetMetaData
+from acceldata.models.api.catalog.label import Label
+from acceldata.models.api.catalog.mini_profile_request import MiniProfileRequest
+from acceldata.models.sdk.catalog.custom_asset_metadata import CustomAssetMetadata
+from acceldata.models.sdk.catalog.profile_request_resource import ProfileRequestResource
+from acceldata.client.transient_retry import RetryConfig
+from acceldata.models.sdk.catalog.profiling import AssetProfilingParams
+
+if TYPE_CHECKING:
+    from acceldata.services.asset_service import AssetService
+
+logger = logging.getLogger("asset_resource")
+
+
+class AssetResource:
+    """
+    SDK wrapper around the generated :class:`~acceldata.models.api.catalog.asset.Asset`
+    for catalog operations scoped to an asset; HTTP is delegated to
+    :class:`~acceldata.services.asset_service.AssetService`.
+    """
+
+    def __init__(self, asset_service: AssetService, model: Asset) -> None:
+        self._asset_service = asset_service
+        self._model = model
+
+    @property
+    def asset_service(self) -> AssetService:
+        return self._asset_service
+
+    @property
+    def asset(self) -> Asset:
+        return self._model
+
+    def to_dict(self) -> Dict[str, Any]:
+        return self._model.to_dict()
+
+    @property
+    def id(self) -> int:
+        if self._model.id is None:
+            raise ValueError("Asset id is required for this operation")
+        return int(self._model.id)
+
+    def __repr__(self) -> str:
+        return f"AssetResource(model={self._model!r})"
+
+    def get_metadata(self) -> CatalogAssetMetaData:
+        return self._asset_service.get_asset_metadata(self.id)
+
+    def add_custom_metadata(
+            self, custom_metadata: List[CustomAssetMetadata]
+    ) -> CatalogAssetMetaData:
+        """Merge key/value pairs and POST them as JSON object (string values)."""
+        merged: dict[str, str] = {}
+        for item in custom_metadata:
+            merged[item.key] = item.value
+        return self._asset_service.add_custom_metadata(self.id, merged)
+
+    def start_profile(
+        self,
+        profiling_params: Optional[AssetProfilingParams] = None,
+        *,
+        sync: bool = False,
+        transient_retry: RetryConfig | None = None,
+    ) -> ProfileRequestResource:
+        """Start profiling for this asset.
+
+        ``sync=False`` (default) triggers profiling asynchronously and returns
+        immediately. ``sync=True`` polls by request id until profiling reaches a
+        terminal status.
+        """
+        if profiling_params is None:
+            raise TypeError("profiling_params is required for start_profile")
+        logger.debug(
+            "Invoked start_profile on AssetResource: profiling_type=%s marker_config=%s",
+            profiling_params.profiling_type,
+            profiling_params.marker_config,
+        )
+        return self._asset_service.profile_asset(
+            self.id,
+            profiling_params,
+            sync=sync,
+            transient_retry=transient_retry,
+        )
+
+    def get_latest_profile_status(self) -> MiniProfileRequest:
+        """GET latest profile status for this asset (``GET .../assets/{id}/profile``)."""
+        return self._asset_service.get_latest_profile_status(self.id)
+
+    def sample_data(self, *, sync: bool = True):
+        return self._asset_service.sample_data(self.id, sync=sync)
+
+    def get_asset_tags(self) -> list[AssetTagInfo]:
+        return self._asset_service.get_asset_tags(self.id)
+
+    def add_asset_tag(self, payload: AssetTagRequest) -> AssetTagInfo:
+        return self._asset_service.add_asset_tag(self.id, payload)
+
+    def get_asset_labels(self) -> list[Label]:
+        return self._asset_service.get_asset_labels(self.id)
+
+    def add_asset_labels(self, payload: AssetLabelRequest) -> list[Label]:
+        return self._asset_service.add_asset_labels(self.id, payload)
+

acceldata/models/sdk/catalog/asset_source_type.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class AssetSourceType(str, Enum):
+    """Catalog datasource / assembly source type (wire values match the catalog API)."""
+
+    BIGQUERY = "BIGQUERY"
+    AZURE_COSMOSDB_CASSANDRA = "AZURE_COSMOSDB_CASSANDRA"
+    CASSANDRA = "CASSANDRA"
+    REDSHIFT = "REDSHIFT"
+    SNOWFLAKE = "SNOWFLAKE"
+    TERADATA = "TERADATA"
+    HIVE = "HIVE"
+    HBASE = "HBASE"
+    ADF = "ADF"
+    AZURE_MSSQL = "AZURE_MSSQL"
+    AZURE_BLOB = "AZURE_BLOB"
+    AZURE_COSMOSDB_NOSQL = "AZURE_COSMOSDB_NOSQL"
+    AZURE_COSMOSDB_POSTGRESQL = "AZURE_COSMOSDB_POSTGRESQL"
+    AMAZON_RDS_POSTGRESQL = "AMAZON_RDS_POSTGRESQL"
+    AMAZON_AURORA_POSTGRESQL = "AMAZON_AURORA_POSTGRESQL"
+    AZURE_DATALAKE = "AZURE_DATALAKE"
+    AWS_GLUE = "AWS_GLUE"
+    AWS_S3 = "AWS_S3"
+    HDFS = "HDFS"
+    GCS = "GCS"
+    ICEBERG = "ICEBERG"
+    KAFKA = "KAFKA"
+    PUBSUB = "PUBSUB"
+    MYSQL = "MYSQL"
+    MARIADB = "MARIADB"
+    MEMSQL = "MEMSQL"
+    POSTGRESQL = "POSTGRESQL"
+    POWERBI = "POWERBI"
+    TABLEAU = "TABLEAU"
+    ORACLE = "ORACLE"
+    AWS_ATHENA = "AWS_ATHENA"
+    DATABRICKS = "DATABRICKS"
+    MONGO = "MONGO"
+    MODEL_BAG = "MODEL_BAG"
+    FEATURE_BAG = "FEATURE_BAG"
+    PRESTO = "PRESTO"
+    TRINO = "TRINO"
+    DB2 = "DB2"
+    CLICKHOUSE = "CLICKHOUSE"
+    SFTP = "SFTP"
+    SAP_HANA = "SAP_HANA"
+    AMAZON_RDS_MYSQL = "AMAZON_RDS_MYSQL"
+    AMAZON_AURORA_MYSQL = "AMAZON_AURORA_MYSQL"
+    AMAZON_RDS_MARIADB = "AMAZON_RDS_MARIADB"
+    AZURE_SYNAPSE_ANALYTICS = "AZURE_SYNAPSE_ANALYTICS"
+    VIRTUAL_DATASOURCE = "VIRTUAL_DATASOURCE"
+    AUTOSYS = "AUTOSYS"
+    DBT_CLOUD = "DBT_CLOUD"
+    FIVETRAN = "FIVETRAN"
+    SNAPLOGIC = "SNAPLOGIC"
+    SALESFORCE = "SALESFORCE"

acceldata/models/sdk/catalog/custom_asset_metadata.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class CustomAssetMetadata:
+    """Key/value pair for custom asset metadata."""
+
+    key: str
+    value: str

acceldata/models/sdk/catalog/datasource_resource.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict
+
+from acceldata.client.transient_retry import RetryConfig
+from acceldata.models.api.catalog.assembly import Assembly
+from acceldata.models.api.catalog.crawler_action_response import CrawlerActionResponse
+from acceldata.models.api.catalog.crawler_status_response import CrawlerStatusResponse
+from acceldata.models.api.catalog.source_type import SourceType
+
+if TYPE_CHECKING:
+    from acceldata.services.datasource_service import DataSourceService
+
+
+class DatasourceResource:
+    """
+    SDK wrapper around catalog :class:`~acceldata.models.api.catalog.assembly.Assembly`
+    (a datasource / assembly) for crawler and reload operations.
+
+    Catalog GET helpers (:meth:`~acceldata.client.adoc_client.AdocClient.get_datasource`,
+    :meth:`~acceldata.client.adoc_client.AdocClient.get_datasources`, …) return this type.
+    You can also build a resource from a bare :class:`~acceldata.models.api.catalog.assembly.Assembly`
+    via     :meth:`~acceldata.client.adoc_client.AdocClient.datasource_resource`.
+    Use :meth:`to_dict` for a wire view; the wrapped :class:`~acceldata.models.api.catalog.assembly.Assembly` is :attr:`assembly`.
+    """
+
+    def __init__(self, datasource_service: DataSourceService, model: Assembly) -> None:
+        self._datasource_service = datasource_service
+        self._model = model
+
+    @property
+    def datasource_service(self) -> DataSourceService:
+        return self._datasource_service
+
+    def to_dict(self) -> Dict[str, Any]:
+        return self._model.to_dict()
+
+    @property
+    def assembly(self) -> Assembly:
+        return self._model
+
+    @property
+    def id(self) -> int | None:
+        return self._model.id
+
+    @property
+    def name(self) -> str:
+        return self._model.name
+
+    @property
+    def source_type(self) -> SourceType:
+        return self._model.source_type
+
+    def __repr__(self) -> str:
+        return f"DatasourceResource(model={self._model!r})"
+
+    def _require_name(self) -> str:
+        n = self._model.name
+        if not n:
+            raise ValueError("Datasource name is required for this operation")
+        return str(n)
+
+    def refresh(self, *, properties: bool = False) -> DatasourceResource:
+        """Reload this assembly from the catalog (by current id or name)."""
+        ident: str | int = self._model.id if self._model.id is not None else self._require_name()
+        fetched = self._datasource_service.get_datasource(ident, properties=properties)
+        self._model = Assembly.model_validate(fetched.to_dict())
+        return self
+
+    def start_crawler(
+        self,
+        *,
+        transient_retry: RetryConfig | None = None,
+    ) -> CrawlerActionResponse:
+        return self._datasource_service.start_crawler(
+            self._require_name(),
+            transient_retry=transient_retry,
+        )
+
+    def get_crawler_status(
+        self,
+        *,
+        transient_retry: RetryConfig | None = None,
+    ) -> CrawlerStatusResponse:
+        return self._datasource_service.get_crawler_status(
+            self._require_name(),
+            transient_retry=transient_retry,
+        )