loxtep 0.2.0__py3-none-any.whl

loxtep/__init__.py

@@ -0,0 +1,68 @@
+"""
+Loxtep Python SDK.
+Grouped by the ingest → define → deliver journey: triggers, connectors, workflows,
+data_products, schemas, quality, catalog, discovery, domains, standards,
+data_contracts, targets. Plus advanced: projects, templates, instances, observe,
+queues, metrics.
+"""
+
+from .client import AsyncLoxtepClient, LoxtepClient
+from .targets import AsyncTargetsApi, TargetsApi
+from .triggers import AsyncTriggersApi, TriggersApi
+from .errors import (
+    AuthenticationError,
+    AuthorizationError,
+    ConflictError,
+    LoxtepError,
+    NotFoundError,
+    RateLimitError,
+    ValidationError,
+    parse_http_error,
+)
+from .http_client import AsyncLoxtepHttpClient, LoxtepHttpClient, RateLimitInfo
+from .sdk_ingest_bundle import (
+    SDK_INGEST_TEMPLATE_ID,
+    build_sdk_ingest_bundle,
+    build_sdk_ingest_local_package,
+    to_local_connector_entity,
+)
+from .models import (
+    DataProduct,
+    DataProductKind,
+    Target,
+    Trigger,
+    UsageMap,
+    UsageMapEdge,
+    UsageMapNode,
+)
+
+__all__ = [
+    "AsyncLoxtepClient",
+    "LoxtepClient",
+    "LoxtepError",
+    "AuthenticationError",
+    "AuthorizationError",
+    "NotFoundError",
+    "ConflictError",
+    "ValidationError",
+    "RateLimitError",
+    "parse_http_error",
+    "LoxtepHttpClient",
+    "AsyncLoxtepHttpClient",
+    "RateLimitInfo",
+    "DataProduct",
+    "DataProductKind",
+    "Target",
+    "Trigger",
+    "TargetsApi",
+    "AsyncTargetsApi",
+    "TriggersApi",
+    "AsyncTriggersApi",
+    "UsageMap",
+    "UsageMapEdge",
+    "UsageMapNode",
+    "SDK_INGEST_TEMPLATE_ID",
+    "build_sdk_ingest_bundle",
+    "build_sdk_ingest_local_package",
+    "to_local_connector_entity",
+]

loxtep/activity.py

@@ -0,0 +1,82 @@
+"""
+Activity API (activity / audit entries). list.
+Internal / experimental — not part of the documented customer surface.
+Backend: /ai/activity.
+"""
+
+from typing import Any, Optional
+
+from .http_client import AsyncLoxtepHttpClient, LoxtepHttpClient
+
+BASE = "/ai/activity"
+
+
+def _unwrap(res: Any) -> Any:
+    return res.get("data", res) if isinstance(res, dict) else res
+
+
+def _query_string(params: dict[str, Any]) -> str:
+    parts = [f"{k}={v}" for k, v in params.items() if v is not None]
+    return "?" + "&".join(parts) if parts else ""
+
+
+class ActivityApi:
+    """Sync activity surface (internal)."""
+
+    def __init__(self, http: LoxtepHttpClient) -> None:
+        self._http = http
+
+    def list(
+        self,
+        *,
+        source: Optional[str] = None,
+        actor: Optional[str] = None,
+        resource_type: Optional[str] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        limit: Optional[int] = None,
+        cursor: Optional[str] = None,
+    ) -> dict[str, Any]:
+        qs = _query_string(
+            {
+                "source": source,
+                "actor": actor,
+                "resource_type": resource_type,
+                "start": start,
+                "end": end,
+                "limit": limit,
+                "cursor": cursor,
+            }
+        )
+        return _unwrap(self._http.get(f"{BASE}{qs}"))
+
+
+class AsyncActivityApi:
+    """Async activity surface (internal)."""
+
+    def __init__(self, http: AsyncLoxtepHttpClient) -> None:
+        self._http = http
+
+    async def list(
+        self,
+        *,
+        source: Optional[str] = None,
+        actor: Optional[str] = None,
+        resource_type: Optional[str] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        limit: Optional[int] = None,
+        cursor: Optional[str] = None,
+    ) -> dict[str, Any]:
+        qs = _query_string(
+            {
+                "source": source,
+                "actor": actor,
+                "resource_type": resource_type,
+                "start": start,
+                "end": end,
+                "limit": limit,
+                "cursor": cursor,
+            }
+        )
+        return _unwrap(await self._http.get(f"{BASE}{qs}"))

loxtep/build.py

@@ -0,0 +1,22 @@
+"""Build facade (MCP: loxtep_build)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from .data_products import DataProductsApi
+from .targets import TargetsApi
+from .triggers import TriggersApi
+from .workflows import WorkflowsApi
+
+
+@dataclass
+class BuildFacade:
+    workflows: WorkflowsApi
+    triggers: TriggersApi
+    data_products: DataProductsApi
+    targets: TargetsApi
+
+    def get_writer(self, workflow_id: str, **options: Any) -> Any:
+        return self.workflows.get_writer(workflow_id, **options)

loxtep/catalog.py

@@ -0,0 +1,48 @@
+"""
+Catalog (search) API. search.
+"""
+
+from typing import Any
+
+from .http_client import AsyncLoxtepHttpClient, LoxtepHttpClient
+
+
+def _query_string(params: dict[str, Any]) -> str:
+    parts = [f"{k}={v}" for k, v in params.items() if v is not None]
+    return "?" + "&".join(parts) if parts else ""
+
+
+class CatalogApi:
+    """Sync catalog surface."""
+
+    def __init__(self, http: LoxtepHttpClient) -> None:
+        self._http = http
+
+    def search(
+        self,
+        query: str,
+        *,
+        type: str = "data_product",
+        limit: int = 20,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        qs = _query_string({"q": query, "type": type, "limit": limit, "offset": offset})
+        return self._http.get(f"/search{qs}")
+
+
+class AsyncCatalogApi:
+    """Async catalog surface."""
+
+    def __init__(self, http: AsyncLoxtepHttpClient) -> None:
+        self._http = http
+
+    async def search(
+        self,
+        query: str,
+        *,
+        type: str = "data_product",
+        limit: int = 20,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        qs = _query_string({"q": query, "type": type, "limit": limit, "offset": offset})
+        return await self._http.get(f"/search{qs}")