dagster-dg-cli 1.12.16__py2.py3-none-any.whl

dagster_dg_cli/__init__.py

@@ -0,0 +1,5 @@
+from dagster_shared.libraries import DagsterLibraryRegistry
+
+from dagster_dg_cli.version import __version__ as __version__
+
+DagsterLibraryRegistry.register("dagster-dg-cli", __version__)

dagster_dg_cli/api_layer/__init__.py

@@ -0,0 +1 @@
+"""Dagster Plus API client library."""

dagster_dg_cli/api_layer/api/__init__.py

@@ -0,0 +1 @@
+"""API client endpoints."""

dagster_dg_cli/api_layer/api/agent.py

@@ -0,0 +1,24 @@
+"""Agent endpoints - REST-like interface."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+from dagster_dg_cli.api_layer.graphql_adapter.agent import (
+    get_agent_via_graphql,
+    list_agents_via_graphql,
+)
+from dagster_dg_cli.utils.plus.gql_client import IGraphQLClient
+
+if TYPE_CHECKING:
+    from dagster_dg_cli.api_layer.schemas.agent import DgApiAgent, DgApiAgentList
+
+
+@dataclass(frozen=True)
+class DgApiAgentApi:
+    client: IGraphQLClient
+
+    def list_agents(self) -> "DgApiAgentList":
+        return list_agents_via_graphql(self.client)
+
+    def get_agent(self, agent_id: str) -> Optional["DgApiAgent"]:
+        return get_agent_via_graphql(self.client, agent_id)

dagster_dg_cli/api_layer/api/asset.py

@@ -0,0 +1,58 @@
+"""Asset endpoints - REST-like interface."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from dagster_dg_cli.api_layer.graphql_adapter.asset import (
+    get_dg_plus_api_asset_via_graphql,
+    get_dg_plus_api_asset_with_status_via_graphql,
+    list_dg_plus_api_assets_via_graphql,
+    list_dg_plus_api_assets_with_status_via_graphql,
+)
+from dagster_dg_cli.utils.plus.gql_client import IGraphQLClient
+
+if TYPE_CHECKING:
+    from dagster_dg_cli.api_layer.schemas.asset import DgApiAsset, DgApiAssetList
+
+
+@dataclass(frozen=True)
+class DgApiAssetApi:
+    client: IGraphQLClient
+
+    def list_assets(
+        self,
+        limit: int | None = 50,
+        cursor: str | None = None,
+        view: str | None = None,
+    ) -> "DgApiAssetList":
+        """List assets with cursor-based pagination and optional view."""
+        from dagster_dg_cli.cli.api.asset import DG_API_MAX_ASSET_LIMIT
+
+        # Enforce max limit constraint
+        if limit and limit > DG_API_MAX_ASSET_LIMIT:
+            raise ValueError(f"Limit cannot exceed {DG_API_MAX_ASSET_LIMIT}")
+
+        # Validate view parameter
+        if view and view not in ["status"]:
+            raise ValueError(f"Invalid view: {view}. Supported views: status")
+
+        if view == "status":
+            return list_dg_plus_api_assets_with_status_via_graphql(
+                self.client, limit=limit, cursor=cursor
+            )
+        else:
+            return list_dg_plus_api_assets_via_graphql(self.client, limit=limit, cursor=cursor)
+
+    def get_asset(self, asset_key: str, view: str | None = None) -> "DgApiAsset":
+        """Get single asset by slash-separated key (e.g., 'foo/bar') with optional view."""
+        # Parse "foo/bar" to ["foo", "bar"]
+        asset_key_parts = asset_key.split("/")
+
+        # Validate view parameter
+        if view and view not in ["status"]:
+            raise ValueError(f"Invalid view: {view}. Supported views: status")
+
+        if view == "status":
+            return get_dg_plus_api_asset_with_status_via_graphql(self.client, asset_key_parts)
+        else:
+            return get_dg_plus_api_asset_via_graphql(self.client, asset_key_parts)

dagster_dg_cli/api_layer/api/deployments.py

@@ -0,0 +1,24 @@
+"""Deployment endpoints - REST-like interface."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from dagster_dg_cli.api_layer.graphql_adapter.deployment import (
+    get_deployment_by_name_via_graphql,
+    list_deployments_via_graphql,
+)
+from dagster_dg_cli.utils.plus.gql_client import IGraphQLClient
+
+if TYPE_CHECKING:
+    from dagster_dg_cli.api_layer.schemas.deployment import Deployment, DeploymentList
+
+
+@dataclass(frozen=True)
+class DgApiDeploymentApi:
+    client: IGraphQLClient
+
+    def list_deployments(self) -> "DeploymentList":
+        return list_deployments_via_graphql(self.client)
+
+    def get_deployment(self, name: str) -> "Deployment":
+        return get_deployment_by_name_via_graphql(self.client, name)

dagster_dg_cli/api_layer/api/run.py

@@ -0,0 +1,21 @@
+"""Run metadata API implementation."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from dagster_dg_cli.api_layer.graphql_adapter.run import get_run_via_graphql
+from dagster_dg_cli.utils.plus.gql_client import IGraphQLClient
+
+if TYPE_CHECKING:
+    from dagster_dg_cli.api_layer.schemas.run import DgApiRun
+
+
+@dataclass(frozen=True)
+class DgApiRunApi:
+    """API for run metadata operations."""
+
+    client: IGraphQLClient
+
+    def get_run(self, run_id: str) -> "DgApiRun":
+        """Get run metadata by ID."""
+        return get_run_via_graphql(self.client, run_id)

dagster_dg_cli/api_layer/api/run_event.py

@@ -0,0 +1,76 @@
+"""Run events API implementation."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from dagster_dg_cli.api_layer.graphql_adapter.run_event import get_run_events_via_graphql
+from dagster_dg_cli.utils.plus.gql_client import IGraphQLClient
+
+if TYPE_CHECKING:
+    from dagster_dg_cli.api_layer.schemas.run_event import RunEventList
+
+
+@dataclass(frozen=True)
+class DgApiRunEventApi:
+    """API for run events operations."""
+
+    client: IGraphQLClient
+
+    def get_events(
+        self,
+        run_id: str,
+        event_types: tuple[str, ...] = (),
+        step_keys: tuple[str, ...] = (),
+        levels: tuple[str, ...] = (),
+        limit: int = 100,
+        after_cursor: str | None = None,
+    ) -> "RunEventList":
+        """Get run events with filtering options."""
+        from dagster_dg_cli.api_layer.schemas.run_event import (
+            DgApiErrorInfo,
+            DgApiRunEvent,
+            RunEventLevel,
+            RunEventList,
+        )
+
+        events_data = get_run_events_via_graphql(
+            self.client,
+            run_id=run_id,
+            limit=limit,
+            after_cursor=after_cursor,
+            event_types=event_types,
+            step_keys=step_keys,
+            levels=levels,
+        )
+
+        # Helper function to convert error data to DgApiErrorInfo recursively
+        def _convert_error_info(error_data: dict | None) -> DgApiErrorInfo | None:
+            if not error_data:
+                return None
+            return DgApiErrorInfo(
+                message=error_data.get("message", ""),
+                className=error_data.get("className"),
+                stack=error_data.get("stack"),
+                cause=_convert_error_info(error_data.get("cause")),
+            )
+
+        # Convert to Pydantic models
+        events = [
+            DgApiRunEvent(
+                run_id=e["runId"],
+                message=e["message"],
+                timestamp=e["timestamp"],
+                level=RunEventLevel[e["level"]],
+                step_key=e.get("stepKey"),
+                event_type=e.get("eventType"),
+                error=_convert_error_info(e.get("error")),
+            )
+            for e in events_data["events"]
+        ]
+
+        return RunEventList(
+            items=events,
+            total=len(events),
+            cursor=events_data.get("cursor"),
+            has_more=events_data.get("hasMore", False),
+        )

dagster_dg_cli/api_layer/api/schedule.py

@@ -0,0 +1,54 @@
+"""Schedule API implementation."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from dagster_dg_cli.api_layer.graphql_adapter.schedule import (
+    get_schedule_via_graphql,
+    list_schedules_via_graphql,
+)
+from dagster_dg_cli.utils.plus.gql_client import IGraphQLClient
+
+if TYPE_CHECKING:
+    from dagster_dg_cli.api_layer.schemas.schedule import DgApiSchedule, DgApiScheduleList
+
+
+@dataclass(frozen=True)
+class DgApiScheduleApi:
+    """API for schedule operations."""
+
+    client: IGraphQLClient
+
+    def list_schedules(
+        self,
+        repository_location_name: str | None = None,
+        repository_name: str | None = None,
+    ) -> "DgApiScheduleList":
+        """List all schedules, optionally filtered by code location and name."""
+        return list_schedules_via_graphql(
+            self.client,
+            repository_location_name=repository_location_name,
+            repository_name=repository_name,
+        )
+
+    def get_schedule(
+        self,
+        schedule_name: str,
+        repository_location_name: str,
+        repository_name: str,
+    ) -> "DgApiSchedule":
+        """Get schedule by name and code location details."""
+        return get_schedule_via_graphql(
+            self.client,
+            schedule_name=schedule_name,
+            repository_location_name=repository_location_name,
+            repository_name=repository_name,
+        )
+
+    def get_schedule_by_name(self, schedule_name: str) -> "DgApiSchedule":
+        """Get schedule by name, searching across all code locations."""
+        from dagster_dg_cli.api_layer.graphql_adapter.schedule import (
+            get_schedule_by_name_via_graphql,
+        )
+
+        return get_schedule_by_name_via_graphql(self.client, schedule_name=schedule_name)

dagster_dg_cli/api_layer/api/secret.py

@@ -0,0 +1,74 @@
+"""Secret endpoints - REST-like interface."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from dagster_dg_cli.api_layer.graphql_adapter.secret import (
+    get_secret_via_graphql,
+    list_secrets_via_graphql,
+)
+from dagster_dg_cli.utils.plus.gql_client import IGraphQLClient
+
+if TYPE_CHECKING:
+    from dagster_dg_cli.api_layer.schemas.secret import DgApiSecret, DgApiSecretList
+
+
+@dataclass(frozen=True)
+class DgApiSecretApi:
+    """Secret API operations."""
+
+    client: IGraphQLClient
+
+    def list_secrets(
+        self,
+        location_name: str | None = None,
+        scope: str | None = None,
+        limit: int | None = None,
+    ) -> "DgApiSecretList":
+        """List secrets with optional filtering.
+
+        Args:
+            location_name: Optional filter by code location name
+            scope: Optional scope filter ("deployment" or "organization")
+            limit: Optional limit on number of results
+
+        Returns:
+            DgApiSecretList: List of secrets (values are never included for security)
+
+        Note:
+            Secret values are never exposed in list operations for security.
+            Use get_secret with include_value=True to retrieve specific values.
+        """
+        return list_secrets_via_graphql(
+            self.client,
+            location_name=location_name,
+            scope=scope,
+            include_values=False,  # Never expose values in list operations
+            limit=limit,
+        )
+
+    def get_secret(
+        self,
+        secret_name: str,
+        location_name: str | None = None,
+        include_value: bool = False,
+    ) -> "DgApiSecret":
+        """Get a specific secret.
+
+        Args:
+            secret_name: Name of the secret to retrieve
+            location_name: Optional filter by code location name
+            include_value: Whether to include the secret value (default: False for security)
+
+        Returns:
+            DgApiSecret: Single secret with optional value
+
+        Raises:
+            ValueError: If secret not found
+        """
+        return get_secret_via_graphql(
+            self.client,
+            secret_name=secret_name,
+            location_name=location_name,
+            include_value=include_value,
+        )

dagster_dg_cli/api_layer/api/sensor.py

@@ -0,0 +1,52 @@
+"""Sensor API implementation."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from dagster_dg_cli.api_layer.graphql_adapter.sensor import (
+    get_sensor_via_graphql,
+    list_sensors_via_graphql,
+)
+from dagster_dg_cli.utils.plus.gql_client import IGraphQLClient
+
+if TYPE_CHECKING:
+    from dagster_dg_cli.api_layer.schemas.sensor import DgApiSensor, DgApiSensorList
+
+
+@dataclass(frozen=True)
+class DgApiSensorApi:
+    """API for sensor operations."""
+
+    client: IGraphQLClient
+
+    def list_sensors(
+        self,
+        repository_location_name: str | None = None,
+        repository_name: str | None = None,
+    ) -> "DgApiSensorList":
+        """List all sensors, optionally filtered by repository location and name."""
+        return list_sensors_via_graphql(
+            self.client,
+            repository_location_name=repository_location_name,
+            repository_name=repository_name,
+        )
+
+    def get_sensor(
+        self,
+        sensor_name: str,
+        repository_location_name: str,
+        repository_name: str,
+    ) -> "DgApiSensor":
+        """Get sensor by name and repository details."""
+        return get_sensor_via_graphql(
+            self.client,
+            sensor_name=sensor_name,
+            repository_location_name=repository_location_name,
+            repository_name=repository_name,
+        )
+
+    def get_sensor_by_name(self, sensor_name: str) -> "DgApiSensor":
+        """Get sensor by name, searching across all repositories."""
+        from dagster_dg_cli.api_layer.graphql_adapter.sensor import get_sensor_by_name_via_graphql
+
+        return get_sensor_by_name_via_graphql(self.client, sensor_name=sensor_name)

dagster_dg_cli/api_layer/graphql_adapter/__init__.py

@@ -0,0 +1 @@
+"""GraphQL adapter layer for Dagster Plus CLI."""

dagster_dg_cli/api_layer/graphql_adapter/agent.py

@@ -0,0 +1,108 @@
+"""GraphQL implementation for agent operations."""
+
+from typing import TYPE_CHECKING, Any, Optional
+
+from dagster_dg_cli.utils.plus.gql_client import IGraphQLClient
+
+if TYPE_CHECKING:
+    from dagster_dg_cli.api_layer.schemas.agent import DgApiAgent, DgApiAgentList
+
+# GraphQL queries
+LIST_AGENTS_QUERY = """
+query ListAgents {
+    agents {
+        id
+        agentLabel
+        status
+        lastHeartbeatTime
+        metadata {
+            key
+            value
+        }
+    }
+}
+"""
+
+# Note: There's no single 'agent' query, so we use 'agents' and filter client-side
+
+
+def process_agents_response(graphql_response: dict[str, Any]) -> "DgApiAgentList":
+    """Process GraphQL response into AgentList.
+
+    This is a pure function that can be easily tested without mocking GraphQL clients.
+
+    Args:
+        graphql_response: Raw GraphQL response containing "agents"
+
+    Returns:
+        AgentList: Processed agent data
+    """
+    # Import pydantic models only when needed
+    from dagster_dg_cli.api_layer.schemas.agent import (
+        DgApiAgent,
+        DgApiAgentList,
+        DgApiAgentMetadataEntry,
+        DgApiAgentStatus,
+    )
+
+    agents_data = graphql_response.get("agents", [])
+
+    agents = []
+    for a in agents_data:
+        metadata = [
+            DgApiAgentMetadataEntry(key=m["key"], value=m["value"]) for m in a.get("metadata", [])
+        ]
+
+        agents.append(
+            DgApiAgent(
+                id=a["id"],
+                agent_label=a.get("agentLabel"),
+                status=DgApiAgentStatus[a["status"]],
+                last_heartbeat_time=a.get("lastHeartbeatTime"),
+                metadata=metadata,
+            )
+        )
+
+    return DgApiAgentList(
+        items=agents,
+        total=len(agents),
+    )
+
+
+def list_agents_via_graphql(
+    client: IGraphQLClient,
+    limit: int | None = None,
+) -> "DgApiAgentList":
+    """Fetch agents using GraphQL.
+    This is an implementation detail that can be replaced with REST calls later.
+    """
+    result = client.execute(LIST_AGENTS_QUERY)
+
+    agent_list = process_agents_response(result)
+
+    # Apply limit if specified
+    if limit is not None:
+        agent_list.items = agent_list.items[:limit]
+        agent_list.total = len(agent_list.items)
+
+    return agent_list
+
+
+def get_agent_via_graphql(
+    client: IGraphQLClient,
+    agent_id: str,
+) -> Optional["DgApiAgent"]:
+    """Fetch single agent using GraphQL.
+    This is an implementation detail that can be replaced with REST calls later.
+
+    Note: Since there's no single 'agent' query, we fetch all agents and filter client-side.
+    """
+    result = client.execute(LIST_AGENTS_QUERY)
+    agent_list = process_agents_response(result)
+
+    # Find the agent with matching ID
+    for agent in agent_list.items:
+        if agent.id == agent_id:
+            return agent
+
+    return None