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

acceldata/urls/catalog_urls.py

@@ -0,0 +1,137 @@
+class CatalogUrls:
+    def __init__(self, base_url: str) -> None:
+        if not base_url.startswith("http"):
+            raise ValueError(f"Invalid base_url: {base_url}")
+        self._base = base_url.rstrip("/")
+
+    def assets_by_ids(self, asset_ids: int | list[int] | tuple[int, ...]) -> str:
+        if isinstance(asset_ids, (list, tuple)):
+            ids = ",".join(str(asset_id) for asset_id in asset_ids)
+        else:
+            ids = str(asset_ids)
+        return f"{self._base}/assets?ids={ids}"
+
+    def assets_by_uid(self, uid: str) -> str:
+        return f"{self._base}/assets?uid={uid}"
+
+    def asset_metadata(self, asset_id: int) -> str:
+        return f"{self._base}/assets/{asset_id}/metadata"
+
+    def asset_custom_metadata(self, asset_id: int) -> str:
+        return f"{self._base}/assets/{asset_id}/metadata/custom"
+
+    def asset_profile(self, asset_id: int) -> str:
+        return f"{self._base}/assets/{asset_id}/profile"
+
+    def profile_request_details(self, asset_id: int, req_id: int) -> str:
+        return f"{self._base}/assets/{asset_id}/profile/{req_id}"
+
+    def profile_cancel(self, profile_req_id: int) -> str:
+        return f"{self._base}/assets/profile/{profile_req_id}/cancel"
+
+    def asset_tags(self, asset_id: int) -> str:
+        return f"{self._base}/assets/{asset_id}/tags"
+
+    def assets_tags(self) -> str:
+        return f"{self._base}/assets/tags"
+
+    def asset_tag(self, asset_id: int) -> str:
+        return f"{self._base}/assets/{asset_id}/tag"
+
+    def asset_labels(self, asset_id: int) -> str:
+        return f"{self._base}/assets/{asset_id}/labels"
+
+    def asset_sample_async(self, asset_id: int) -> str:
+        return f"{self._base}/assets/{asset_id}/sample/async"
+
+    def asset_sample_result(self, request_id: str) -> str:
+        return f"{self._base}/assets/sample/result/{request_id}"
+
+    def asset_types(self) -> str:
+        return f"{self._base}/asset-types"
+
+    def source_types(self) -> str:
+        return f"{self._base}/source-types"
+
+    def connection_types(self) -> str:
+        return f"{self._base}/connection-types"
+
+    def crawl_datasource(self,datasource_name: str) -> str:
+        return f"{self._base}/crawler/{datasource_name}"
+
+    def datasources(self) -> str:
+        return f"{self._base}/assemblies"
+
+    def assembly_resource(self, assembly_identifier: str | int) -> str:
+        """Path to one assembly (datasource) without query string (e.g. DELETE)."""
+        return f"{self._base}/assemblies/{assembly_identifier}"
+
+    def assembly(self, assembly_identifier: str | int, *, properties: bool = False) -> str:
+        """GET single assembly (datasource) by numeric id or name."""
+        base = self.assembly_resource(assembly_identifier)
+        return f"{base}?properties={'true' if properties else 'false'}"
+
+    def analytics_pipeline(self, pipeline_identifier: str | int) -> str:
+        """GET one analytics pipeline by numeric id or name (path segment)."""
+        return f"{self._base}/analytics-pipelines/{pipeline_identifier}"
+
+    def rules(self)->str:
+        return f"{self._base}/rules"
+
+    def rules_executions(self) -> str:
+        """GET ``/rules/executions`` — list executions (use query params ``ruleId``, ``page``, ``size``, ``sortBy``)."""
+        return f"{self.rules()}/executions"
+
+    def rule_by_identifier(self, identifier: str | int) -> str:
+        """GET ``/rules/{identifier}`` — generic rule (``QualityRule``)."""
+        return f"{self.rules()}/{identifier}"
+
+    def data_quality_rule(self, identifier: str | int) -> str:
+        """GET ``/rules/data-quality/{identifier}`` — DQ rule payload (``RuleResponse``)."""
+        return f"{self.rules()}/data-quality/{identifier}"
+
+    def reconciliation_rule(self, identifier: str | int) -> str:
+        """GET ``/rules/reconciliation/{identifier}``."""
+        return f"{self.rules()}/reconciliation/{identifier}"
+
+    def data_cadence_rule(self, identifier: str | int) -> str:
+        """GET ``/rules/data-cadence/{identifier}``."""
+        return f"{self.rules()}/data-cadence/{identifier}"
+
+    def data_quality_rule_executions(self, rule_id: str | int) -> str:
+        return f"{self.rules()}/data-quality/{rule_id}/executions"
+
+    def reconciliation_rule_executions(self, rule_id: str | int) -> str:
+        return f"{self.rules()}/reconciliation/{rule_id}/executions"
+
+    def data_cadence_rule_executions(self, rule_id: str | int) -> str:
+        return f"{self.rules()}/data-cadence/{rule_id}/executions"
+
+    def data_quality_rule_execution(self, execution_id: str | int) -> str:
+        """GET ``/rules/data-quality/executions/{execution_id}`` — DQ execution details."""
+        return f"{self.rules()}/data-quality/executions/{execution_id}"
+
+    def data_quality_rule_execution_result(self, execution_id: str | int) -> str:
+        return f"{self.rules()}/data-quality/executions/{execution_id}/result"
+
+    def reconciliation_rule_execution(self, execution_id: str | int) -> str:
+        """GET ``/rules/reconciliation/executions/{execution_id}`` — execution details (Reconciliation.Execution)."""
+        return f"{self.rules()}/reconciliation/executions/{execution_id}"
+
+    def reconciliation_rule_execution_result(self, execution_id: str | int) -> str:
+        return f"{self.rules()}/reconciliation/executions/{execution_id}/result"
+
+    def data_cadence_rule_execution_result(self, execution_id: str | int) -> str:
+        return f"{self.rules()}/data-cadence/executions/{execution_id}/result"
+
+    def data_cadence_rule_execution(self, execution_id: str | int) -> str:
+        """GET ``/rules/data-cadence/executions/{execution_id}`` — cadence execution details."""
+        return f"{self.rules()}/data-cadence/executions/{execution_id}"
+
+    def cancel_rule_execution(self, execution_id: str | int) -> str:
+        return f"{self.rules()}/execution/{execution_id}/cancel"
+
+    def rule_enable(self, rule_id: str | int) -> str:
+        """PUT ``/rules/{rule_id}/enable`` — body ``EnableRuleRequest`` (``enable`` true/false)."""
+        return f"{self.rules()}/{rule_id}/enable"
+

acceldata/urls/pipeline_urls.py

@@ -0,0 +1,55 @@
+class PipelineUrls:
+    """Build pipeline control-plane REST paths (see :data:`~acceldata.constants.PIPELINE_API_PATH`)."""
+
+    def __init__(self, base_url: str) -> None:
+        if not base_url.startswith("http"):
+            raise ValueError(f"Invalid base_url: {base_url}")
+        self._base = base_url.rstrip("/")
+
+    def pipelines_root(self) -> str:
+        return f"{self._base}/pipelines"
+
+    def pipeline_by_identity(self, identity: str | int) -> str:
+        return f"{self._base}/pipelines/{identity}"
+
+    def pipelines_summary(self) -> str:
+        return f"{self._base}/pipelines/summary"
+
+    def pipeline_jobs(self, pipeline_id: int) -> str:
+        return f"{self._base}/pipelines/{pipeline_id}/jobs"
+
+    def pipeline_runs(self, pipeline_id: int) -> str:
+        return f"{self._base}/pipelines/{pipeline_id}/runs"
+
+    def pipeline_latest_run(self, pipeline_id: int) -> str:
+        return f"{self._base}/pipelines/{pipeline_id}/latestRun"
+
+    def pipeline_run_by_id(self, pipeline_run_id: int) -> str:
+        return f"{self._base}/pipelines/runs/{pipeline_run_id}"
+
+    def pipeline_run_spans(self, pipeline_run_id: int) -> str:
+        return f"{self._base}/pipelines/runs/{pipeline_run_id}/spans"
+
+    def pipeline_run_span_by_uid(self, pipeline_run_id: int, span_identity: str) -> str:
+        return f"{self._base}/pipelines/runs/{pipeline_run_id}/spans/{span_identity}"
+
+    def span_child_spans(self, span_id: int) -> str:
+        return f"{self._base}/pipelines/spans/{span_id}/childSpans"
+
+    def span_events(self, span_id: int) -> str:
+        return f"{self._base}/pipelines/spans/{span_id}/events"
+
+    def pipeline_graph(self, pipeline_id: int) -> str:
+        return f"{self._base}/pipelines/{pipeline_id}/graph"
+
+
+    def pipeline_graph_by_version_id(self, pipeline_id: int,version_id: int) -> str:
+        return f"{self._base}/pipelines/{pipeline_id}/graph?versionId={version_id}"
+
+    def pipeline_summary(self) -> str:
+        """Deprecated alias for :meth:`pipelines_summary`."""
+        return self.pipelines_summary()
+
+    def pipeline_identity(self, identity: str | int) -> str:
+        """Deprecated alias for :meth:`pipeline_by_id`."""
+        return self.pipeline_by_identity(identity)

acceldata/utils/__init__.py

@@ -0,0 +1,6 @@
+"""Utilities for the Acceldata Python SDK."""
+
+from acceldata.utils.datetime_utils import DateTimeFormatter
+from acceldata.utils.time_range_utils import TimeRangeCalculator
+
+__all__ = ["DateTimeFormatter", "TimeRangeCalculator"]

acceldata/utils/datetime_utils.py

@@ -0,0 +1,16 @@
+"""Datetime helpers aligned with prior SDK behavior for pipeline span events."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Optional
+
+
+class DateTimeFormatter:
+    @staticmethod
+    def format_datetime(date_time: Optional[datetime]) -> Optional[str]:
+        if date_time is None:
+            return None
+        if isinstance(date_time, datetime):
+            return date_time.isoformat()
+        raise ValueError("Input is not a valid datetime object")

acceldata/utils/operation_ack.py

@@ -0,0 +1,22 @@
+"""Debug-level operation outcome markers for integration and support logs."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+
+def ack_success(logger: logging.Logger, operation: str, **context: Any) -> None:
+    """Log a successful SDK operation (debug only)."""
+    if context:
+        logger.debug("ack success %s %r", operation, context)
+    else:
+        logger.debug("ack success %s", operation)
+
+
+def ack_failure(logger: logging.Logger, operation: str, reason: str, **context: Any) -> None:
+    """Log a failed or skipped SDK operation (debug only)."""
+    if context:
+        logger.debug("ack failure %s reason=%s %r", operation, reason, context)
+    else:
+        logger.debug("ack failure %s reason=%s", operation, reason)

acceldata/utils/span_helpers.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, List, Optional
+
+from acceldata.models.api.pipeline.span import Span
+from acceldata.utils.datetime_utils import DateTimeFormatter
+
+if TYPE_CHECKING:
+    from acceldata.services.pipeline_service import PipelineService
+
+
+
+def normalize_span_event_created_at(created_at: Optional[datetime]) -> Optional[datetime]:
+    """Validate and normalize explicit event time (ISO-style strings + parse for API models)."""
+    raw = DateTimeFormatter.format_datetime(created_at)
+    if raw is None:
+        return None
+    return datetime.fromisoformat(raw.replace("Z", "+00:00"))
+
+
+def span_create_payload(
+        *,
+        pipeline_run_id: int,
+        uid: str,
+        associated_job_uids: List[str],
+        parent_span_id: Optional[int] = None,
+        created_at: Optional[datetime] = None,
+        updated_at: Optional[datetime] = None,
+) -> dict[str, Any]:
+    """JSON body for ``POST .../pipelineRuns/{id}/spans`` (control-plane contract).
+
+    Optional ``created_at`` / ``updated_at`` are sent as ``createdAt`` / ``updatedAt`` (ISO-8601
+    strings) for explicit-time flows, matching :meth:`Pipeline.create_span` from the earlier SDK.
+    """
+    span_obj: dict[str, Any] = {
+        "uid": uid,
+        "pipelineRunId": pipeline_run_id,
+        "status": "INITIALIZED",
+    }
+    if parent_span_id is not None:
+        span_obj["parentSpanId"] = parent_span_id
+    if created_at is not None:
+        span_obj["createdAt"] = created_at.isoformat()
+    if updated_at is not None:
+        span_obj["updatedAt"] = updated_at.isoformat()
+    return {"span": span_obj, "associatedJobUids": associated_job_uids}
+
+
+def ensure_span_for_job(
+        service: PipelineService,
+        *,
+        pipeline_run_id: int,
+        span_uid: str,
+        job_uid: str,
+        created_at: Optional[datetime] = None,
+        updated_at: Optional[datetime] = None,
+) -> Span:
+    """
+    When ``bounded_by_span`` is True: create a span for the job.
+
+    Guarantee a root span exists for the run, then create a child span under that root and
+    associate the job to the child span.
+    """
+    root_span_resource = service.get_root_span(pipeline_run_id)
+    associated: List[str] = [job_uid]
+
+    if root_span_resource is None:
+        # Root span UID is internal and deterministic for a run; job association happens on child.
+        root_span_resource = service.create_span(
+            pipeline_run_id,
+            span_create_payload(
+                pipeline_run_id=pipeline_run_id,
+                uid=f"pipeline-run-{pipeline_run_id}-root",
+                associated_job_uids=[],
+                created_at=created_at,
+                updated_at=updated_at,
+            ),
+        )
+
+    root_span_id = getattr(root_span_resource, "id", None)
+    if root_span_id is None:
+        raise ValueError("Root span has no numeric id; cannot create child span")
+
+    return service.create_span(
+        pipeline_run_id,
+        span_create_payload(
+            pipeline_run_id=pipeline_run_id,
+            uid=span_uid,
+            associated_job_uids=associated,
+            parent_span_id=int(root_span_id),
+            created_at=created_at,
+            updated_at=updated_at,
+        ),
+    )

acceldata/utils/time_range_utils.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+
+from acceldata.models.sdk.catalog.policy_filter import ExecutionPeriod, PolicyFilter
+
+
+class TimeRangeCalculator:
+    """Compute ``startedAfter`` / ``finishedBefore`` ranges for :class:`PolicyFilter`."""
+
+    @staticmethod
+    def check_int(input_str: str) -> bool:
+        try:
+            int(input_str)
+            return True
+        except ValueError:
+            return False
+
+    @staticmethod
+    def calculate_minutes_before_time(minutes: int) -> tuple[datetime, datetime]:
+        finished_before_time = datetime.now()
+        started_after_time = finished_before_time - timedelta(minutes=minutes)
+        return started_after_time, finished_before_time
+
+    @staticmethod
+    def calculate_hours_before_time(hours: int) -> tuple[datetime, datetime]:
+        finished_before_time = datetime.now()
+        started_after_time = finished_before_time - timedelta(hours=hours)
+        return started_after_time, finished_before_time
+
+    @staticmethod
+    def calculate_days_before_time(days: int) -> tuple[datetime, datetime]:
+        now = datetime.now()
+        min_time = datetime.min.time()
+        started_after_time = datetime.combine((now - timedelta(days=days)).date(), min_time)
+        finished_before_time = datetime.combine(now.date(), min_time)
+        return started_after_time, finished_before_time
+
+    @staticmethod
+    def calculate_months_before_time(months_before: int) -> tuple[datetime, datetime]:
+        now = datetime.now()
+        finished_before_time = datetime(now.year, now.month, 1)
+        y, m = now.year, now.month
+        m -= months_before
+        while m <= 0:
+            m += 12
+            y -= 1
+        started_after_time = datetime(y, m, 1)
+        return started_after_time, finished_before_time
+
+    @staticmethod
+    def calculate_time_range(policy_filter: PolicyFilter) -> tuple[datetime, datetime | None]:
+        if policy_filter.period is None:
+            raise ValueError("policy_filter.period is required for time range calculation")
+
+        now = datetime.now()
+        finished_before_time = now
+        started_after_time: datetime | None = None
+
+        period = policy_filter.period
+        if period == ExecutionPeriod.Last15minutes:
+            started_after_time, finished_before_time = TimeRangeCalculator.calculate_minutes_before_time(15)
+        elif period == ExecutionPeriod.Last30minutes:
+            started_after_time, finished_before_time = TimeRangeCalculator.calculate_minutes_before_time(30)
+        elif period == ExecutionPeriod.Last1hour:
+            started_after_time, finished_before_time = TimeRangeCalculator.calculate_hours_before_time(1)
+        elif period == ExecutionPeriod.Last3hours:
+            started_after_time, finished_before_time = TimeRangeCalculator.calculate_hours_before_time(3)
+        elif period == ExecutionPeriod.Last6hours:
+            started_after_time, finished_before_time = TimeRangeCalculator.calculate_hours_before_time(6)
+        elif period == ExecutionPeriod.Last12hours:
+            started_after_time, finished_before_time = TimeRangeCalculator.calculate_hours_before_time(12)
+        elif period == ExecutionPeriod.Last24hours:
+            started_after_time, finished_before_time = TimeRangeCalculator.calculate_hours_before_time(24)
+        elif period == ExecutionPeriod.Today:
+            started_after_time = datetime.combine(datetime.now().date(), datetime.min.time())
+        elif period == ExecutionPeriod.Yesterday:
+            started_after_time, finished_before_time = TimeRangeCalculator.calculate_days_before_time(1)
+        elif period == ExecutionPeriod.Last7days:
+            started_after_time, finished_before_time = TimeRangeCalculator.calculate_days_before_time(7)
+        elif period == ExecutionPeriod.Thismonth:
+            started_after_time = datetime(now.year, now.month, 1)
+        elif period == ExecutionPeriod.Last1month:
+            started_after_time, finished_before_time = TimeRangeCalculator.calculate_months_before_time(1)
+        elif period == ExecutionPeriod.Last3month:
+            started_after_time, finished_before_time = TimeRangeCalculator.calculate_months_before_time(3)
+        else:
+            raise ValueError(f"Unsupported ExecutionPeriod: {period!r}")
+
+        return finished_before_time, started_after_time

acceldata_sdk_python-26.7.0.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: acceldata_sdk_python
+Version: 26.7.0
+Summary: Acceldata SDK Python
+Author-email: acceldata <apisupport@acceldata.io>
+License-Expression: MIT
+Keywords: acceldata-sdk-python
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2
+Requires-Dist: requests
+Requires-Dist: requests-toolbelt
+Requires-Dist: semantic-version
+Provides-Extra: release
+Requires-Dist: build>=1; extra == "release"
+Requires-Dist: twine>=5; extra == "release"
+Dynamic: license-file
+
+# Acceldata SDK for Python
+
+Documentation: https://docs.acceldata.io/documentation/acceldata-sdk-python