getdx 0.1.0__py3-none-any.whl

getdx/__init__.py

@@ -0,0 +1,51 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("getdx")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+from getdx.client import DXClient
+from getdx.config import DXClientConfig, DXDataCloudConfig, DXWebConfig, RetryConfig
+from getdx.data_cloud.client import DXDataCloudClient
+from getdx.errors import (
+    DXAPIError,
+    DXArgumentError,
+    DXAuthError,
+    DXClientConfigurationError,
+    DXClientNotConfiguredError,
+    DXFeatureUnavailableError,
+    DXPermissionError,
+    DXRateLimitError,
+    DXResponseError,
+    DXServerError,
+    DXTransportError,
+    DXValidationError,
+)
+from getdx.web.aggregates import EntityOverview, EntityRelationsGraph
+from getdx.web.client import DXWebClient
+
+__all__ = [
+    "DXAPIError",
+    "DXArgumentError",
+    "DXAuthError",
+    "DXClient",
+    "DXClientConfig",
+    "DXClientConfigurationError",
+    "DXClientNotConfiguredError",
+    "DXDataCloudClient",
+    "DXDataCloudConfig",
+    "DXFeatureUnavailableError",
+    "DXPermissionError",
+    "DXRateLimitError",
+    "DXResponseError",
+    "DXServerError",
+    "DXTransportError",
+    "DXValidationError",
+    "DXWebClient",
+    "DXWebConfig",
+    "EntityOverview",
+    "EntityRelationsGraph",
+    "RetryConfig",
+    "__version__",
+]

getdx/client.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from getdx.config import DXClientConfig, DXDataCloudConfig, DXWebConfig
+from getdx.data_cloud.client import DXDataCloudClient
+from getdx.errors import DXClientConfigurationError, DXClientNotConfiguredError
+from getdx.web.client import DXWebClient
+
+
+class DXClient:
+    def __init__(
+        self,
+        *,
+        web: DXWebConfig | None = None,
+        data_cloud: DXDataCloudConfig | None = None,
+        config: DXClientConfig | None = None,
+    ) -> None:
+        resolved_web = web if web is not None else (config.web if config is not None else None)
+        resolved_data_cloud = (
+            data_cloud
+            if data_cloud is not None
+            else (config.data_cloud if config is not None else None)
+        )
+
+        if resolved_web is None and resolved_data_cloud is None:
+            raise DXClientConfigurationError(
+                "DXClient requires at least one API config. Provide web=DXWebConfig(...) "
+                "and/or data_cloud=DXDataCloudConfig(...)."
+            )
+
+        self._web = DXWebClient(resolved_web) if resolved_web is not None else None
+        self._data_cloud = (
+            DXDataCloudClient(resolved_data_cloud) if resolved_data_cloud is not None else None
+        )
+
+    @property
+    def has_web(self) -> bool:
+        return self._web is not None
+
+    @property
+    def has_data_cloud(self) -> bool:
+        return self._data_cloud is not None
+
+    @property
+    def web(self) -> DXWebClient:
+        if self._web is None:
+            raise DXClientNotConfiguredError(
+                "DXClient.web is not configured. "
+                "Pass web=DXWebConfig(...) when constructing DXClient."
+            )
+        return self._web
+
+    @property
+    def data_cloud(self) -> DXDataCloudClient:
+        if self._data_cloud is None:
+            raise DXClientNotConfiguredError(
+                "DXClient.data_cloud is not configured. Pass data_cloud=DXDataCloudConfig(...) "
+                "when constructing DXClient."
+            )
+        return self._data_cloud
+
+    def close(self) -> None:
+        if self._web is not None:
+            self._web.close()
+        if self._data_cloud is not None:
+            self._data_cloud.close()
+
+    def __enter__(self) -> DXClient:
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:  # type: ignore[no-untyped-def]
+        self.close()

getdx/config.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+
+DEFAULT_WEB_BASE_URL = "https://api.getdx.com"
+DEFAULT_TIMEOUT_SECONDS = 30.0
+DEFAULT_DATA_CLOUD_URL_TEMPLATE = "https://{instance}.getdx.net/api"
+
+
+@dataclass(frozen=True)
+class RetryConfig:
+    max_attempts: int = 3
+    backoff_base_seconds: float = 0.25
+    backoff_max_seconds: float = 2.0
+    retry_statuses: tuple[int, ...] = (429, 500, 502, 503, 504)
+
+
+@dataclass(frozen=True)
+class APITransportConfig:
+    base_url: str
+    timeout_seconds: float
+    user_agent: str
+    retry: RetryConfig
+
+
+@dataclass(frozen=True)
+class DXWebConfig:
+    token: str | None = None
+    base_url: str = DEFAULT_WEB_BASE_URL
+    timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS
+    user_agent: str = "getdx/web"
+    retry: RetryConfig = field(default_factory=RetryConfig)
+
+    def resolved_token(self) -> str:
+        token = self.token or os.getenv("DX_WEB_API_TOKEN")
+        if not token:
+            raise ValueError(
+                "DX Web API token missing. Set DX_WEB_API_TOKEN or pass token in DXWebConfig."
+            )
+        return token
+
+    def resolved_transport_config(self) -> APITransportConfig:
+        return APITransportConfig(
+            base_url=self.base_url.rstrip("/"),
+            timeout_seconds=self.timeout_seconds,
+            user_agent=self.user_agent,
+            retry=self.retry,
+        )
+
+
+@dataclass(frozen=True)
+class DXDataCloudConfig:
+    token: str | None = None
+    instance: str | None = None
+    base_url: str | None = None
+    timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS
+    user_agent: str = "getdx/data-cloud"
+    retry: RetryConfig = field(default_factory=RetryConfig)
+
+    def resolved_token(self) -> str:
+        token = self.token or os.getenv("DX_DATA_CLOUD_TOKEN")
+        if not token:
+            raise ValueError(
+                "DX Data Cloud token missing. "
+                "Set DX_DATA_CLOUD_TOKEN or pass token in DXDataCloudConfig."
+            )
+        return token
+
+    def resolved_base_url(self) -> str:
+        if self.base_url:
+            return self.base_url.rstrip("/")
+
+        instance = self.instance or os.getenv("DX_DATA_CLOUD_INSTANCE")
+        if not instance:
+            raise ValueError(
+                "DX Data Cloud base URL cannot be resolved. "
+                "Set DX_DATA_CLOUD_INSTANCE or pass instance/base_url in DXDataCloudConfig."
+            )
+
+        return DEFAULT_DATA_CLOUD_URL_TEMPLATE.format(instance=instance).rstrip("/")
+
+    def resolved_transport_config(self) -> APITransportConfig:
+        return APITransportConfig(
+            base_url=self.resolved_base_url(),
+            timeout_seconds=self.timeout_seconds,
+            user_agent=self.user_agent,
+            retry=self.retry,
+        )
+
+
+@dataclass(frozen=True)
+class DXClientConfig:
+    web: DXWebConfig | None = None
+    data_cloud: DXDataCloudConfig | None = None

getdx/data_cloud/__init__.py

@@ -0,0 +1,4 @@
+from getdx.data_cloud.client import DXDataCloudClient
+from getdx.data_cloud.operations import OPERATION_INDEX, OPERATIONS
+
+__all__ = ["OPERATIONS", "OPERATION_INDEX", "DXDataCloudClient"]

getdx/data_cloud/client.py

@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from getdx.config import DXDataCloudConfig
+from getdx.data_cloud.services import (
+    AiToolMetricsService,
+    CustomDataService,
+    DeploymentsService,
+    IncidentsService,
+    PipelineRunsService,
+    RepoGroupsService,
+)
+from getdx.errors import DXArgumentError
+from getdx.helpers import JSONReturn
+from getdx.http.transport import DXTransport
+from getdx.types import BodyValue
+
+
+class CustomDataAPI:
+    def __init__(self, service: CustomDataService) -> None:
+        self._service = service
+
+    def get(
+        self,
+        *,
+        id: str | None = None,
+        reference: str | None = None,
+        key: str | None = None,
+    ) -> JSONReturn:
+        if id is not None:
+            if reference is not None or key is not None:
+                raise DXArgumentError(
+                    "Pass either id or reference+key for custom_data.get, not both."
+                )
+            return self._service.get(id=id)
+
+        if reference is not None and key is not None:
+            return self._service.get(reference=reference, key=key)
+
+        raise DXArgumentError("custom_data.get requires id or both reference and key.")
+
+    def get_all_by_reference(self, reference: str) -> JSONReturn:
+        return self._service.get_all_by_reference(reference=reference)
+
+    def set(
+        self,
+        *,
+        reference: BodyValue,
+        key: BodyValue,
+        value: BodyValue,
+        timestamp: BodyValue | None = None,
+    ) -> JSONReturn:
+        return self._service.set(reference=reference, key=key, value=value, timestamp=timestamp)
+
+    def set_all(self, *, data: BodyValue) -> JSONReturn:
+        return self._service.set_all(data=data)
+
+    def delete(
+        self,
+        *,
+        id: str | None = None,
+        reference: str | None = None,
+        key: str | None = None,
+    ) -> JSONReturn:
+        if id is not None:
+            if reference is not None or key is not None:
+                raise DXArgumentError(
+                    "Pass either id or reference+key for custom_data.delete, not both."
+                )
+            return self._service.delete(payload={"id": id})
+
+        if reference is not None and key is not None:
+            return self._service.delete(payload={"reference": reference, "key": key})
+
+        raise DXArgumentError("custom_data.delete requires id or both reference and key.")
+
+    def delete_by_id(self, id: str) -> JSONReturn:
+        return self._service.delete(payload={"id": id})
+
+    def delete_by_reference_key(self, reference: str, key: str) -> JSONReturn:
+        return self._service.delete(payload={"reference": reference, "key": key})
+
+    def delete_all_by_reference(self, *, reference: BodyValue) -> JSONReturn:
+        return self._service.delete_all_by_reference(reference=reference)
+
+
+class RepoGroupsAPI:
+    def __init__(self, service: RepoGroupsService) -> None:
+        self._service = service
+
+    def get(self, *, id: str | None = None, reference_id: str | None = None) -> JSONReturn:
+        selector = _exactly_one_selector(
+            id=id, reference_id=reference_id, method_name="repo_groups.get"
+        )
+        return self._service.get(**selector)
+
+    def delete(
+        self, *, id: BodyValue | None = None, reference_id: BodyValue | None = None
+    ) -> JSONReturn:
+        selector = _exactly_one_selector(
+            id=id,
+            reference_id=reference_id,
+            method_name="repo_groups.delete",
+        )
+        return self._service.delete(**selector)
+
+    def upsert(
+        self,
+        *,
+        name: BodyValue,
+        id: BodyValue | None = None,
+        reference_id: BodyValue | None = None,
+        parent_id: BodyValue | None = None,
+        repos: BodyValue | None = None,
+    ) -> JSONReturn:
+        return self._service.upsert(
+            name=name,
+            id=id,
+            reference_id=reference_id,
+            parent_id=parent_id,
+            repos=repos,
+        )
+
+    def add_repos(
+        self,
+        *,
+        repos: BodyValue,
+        id: BodyValue | None = None,
+        reference_id: BodyValue | None = None,
+    ) -> JSONReturn:
+        selector = _exactly_one_selector(
+            id=id,
+            reference_id=reference_id,
+            method_name="repo_groups.add_repos",
+        )
+        return self._service.add_repos(repos=repos, **selector)
+
+    def remove_repos(
+        self,
+        *,
+        repos: BodyValue,
+        id: BodyValue | None = None,
+        reference_id: BodyValue | None = None,
+    ) -> JSONReturn:
+        selector = _exactly_one_selector(
+            id=id,
+            reference_id=reference_id,
+            method_name="repo_groups.remove_repos",
+        )
+        return self._service.remove_repos(repos=repos, **selector)
+
+
+class DeploymentsAPI:
+    def __init__(self, service: DeploymentsService) -> None:
+        self._service = service
+
+    def create(
+        self,
+        *,
+        deployed_at: BodyValue,
+        service: BodyValue,
+        commit_sha: BodyValue | None = None,
+        integration_branch: BodyValue | None = None,
+        merge_commit_shas: BodyValue | None = None,
+        metadata: BodyValue | None = None,
+        reference_id: BodyValue | None = None,
+        repository: BodyValue | None = None,
+        source_name: BodyValue | None = None,
+        source_url: BodyValue | None = None,
+        success: BodyValue | None = None,
+    ) -> JSONReturn:
+        return self._service.create(
+            deployed_at=deployed_at,
+            service=service,
+            commit_sha=commit_sha,
+            integration_branch=integration_branch,
+            merge_commit_shas=merge_commit_shas,
+            metadata=metadata,
+            reference_id=reference_id,
+            repository=repository,
+            source_name=source_name,
+            source_url=source_url,
+            success=success,
+        )
+
+    def set_pull_services(self, *, payload: dict[str, Any]) -> JSONReturn:
+        return self._service.set_pull_services(payload=payload)
+
+    def set_pull_services_by_github_pull_id(
+        self,
+        *,
+        github_pull_id: int,
+        services: Sequence[dict[str, Any]],
+    ) -> JSONReturn:
+        return self._service.set_pull_services(
+            payload={
+                "github_pull_id": github_pull_id,
+                "services": list(services),
+            }
+        )
+
+    def set_pull_services_by_repo_and_number(
+        self,
+        *,
+        repository: str,
+        pull_number: int,
+        services: Sequence[dict[str, Any]],
+    ) -> JSONReturn:
+        return self._service.set_pull_services(
+            payload={
+                "repository": repository,
+                "pull_number": pull_number,
+                "services": list(services),
+            }
+        )
+
+
+class PipelineRunsAPI:
+    def __init__(self, service: PipelineRunsService) -> None:
+        self._service = service
+
+    def upsert(
+        self,
+        *,
+        pipeline_name: BodyValue,
+        pipeline_source: BodyValue,
+        reference_id: BodyValue,
+        started_at: BodyValue,
+        commit_sha: BodyValue | None = None,
+        email: BodyValue | None = None,
+        finished_at: BodyValue | None = None,
+        github_username: BodyValue | None = None,
+        gitlab_username: BodyValue | None = None,
+        head_branch: BodyValue | None = None,
+        pr_number: BodyValue | None = None,
+        repository: BodyValue | None = None,
+        source_url: BodyValue | None = None,
+        status: BodyValue | None = None,
+    ) -> JSONReturn:
+        if (commit_sha is not None or pr_number is not None) and repository is None:
+            raise DXArgumentError(
+                "pipeline_runs.upsert requires repository when commit_sha/pr_number is set."
+            )
+
+        return self._service.upsert(
+            pipeline_name=pipeline_name,
+            pipeline_source=pipeline_source,
+            reference_id=reference_id,
+            started_at=started_at,
+            commit_sha=commit_sha,
+            email=email,
+            finished_at=finished_at,
+            github_username=github_username,
+            gitlab_username=gitlab_username,
+            head_branch=head_branch,
+            pr_number=pr_number,
+            repository=repository,
+            source_url=source_url,
+            status=status,
+        )
+
+
+class DXDataCloudClient:
+    def __init__(self, config: DXDataCloudConfig) -> None:
+        self._config = config
+        self._transport = DXTransport(
+            config=config.resolved_transport_config(),
+            token=config.resolved_token(),
+            api_name="data_cloud",
+        )
+
+        self.ai_tool_metrics = AiToolMetricsService(self._transport)
+        self.custom_data = CustomDataAPI(CustomDataService(self._transport))
+        self.deployments = DeploymentsAPI(DeploymentsService(self._transport))
+        self.incidents = IncidentsService(self._transport)
+        self.pipeline_runs = PipelineRunsAPI(PipelineRunsService(self._transport))
+        self.repo_groups = RepoGroupsAPI(RepoGroupsService(self._transport))
+
+    @property
+    def config(self) -> DXDataCloudConfig:
+        return self._config
+
+    def close(self) -> None:
+        self._transport.close()
+
+
+def _exactly_one_selector(
+    *,
+    id: Any,
+    reference_id: Any,
+    method_name: str,
+) -> dict[str, Any]:
+    if id is not None and reference_id is not None:
+        raise DXArgumentError(f"{method_name} accepts either id or reference_id, not both.")
+    if id is None and reference_id is None:
+        raise DXArgumentError(f"{method_name} requires id or reference_id.")
+    if id is not None:
+        return {"id": id}
+    return {"reference_id": reference_id}