qodalis-cli-server-plugin-data-explorer 1.0.0b13__py3-none-any.whl

qodalis_cli_data_explorer/__init__.py

@@ -0,0 +1,11 @@
+"""Qodalis CLI Data Explorer plugin — registry, executor, and controller."""
+
+from .data_explorer_registry import DataExplorerRegistry
+from .data_explorer_executor import DataExplorerExecutor
+from .data_explorer_controller import create_data_explorer_router
+
+__all__ = [
+    "DataExplorerRegistry",
+    "DataExplorerExecutor",
+    "create_data_explorer_router",
+]

qodalis_cli_data_explorer/data_explorer_controller.py

@@ -0,0 +1,77 @@
+"""FastAPI router for the Data Explorer API."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from typing import Any
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from .data_explorer_executor import DataExplorerExecutor
+from .data_explorer_registry import DataExplorerRegistry
+
+
+def _to_camel(snake: str) -> str:
+    """Convert a snake_case string to camelCase."""
+    parts = snake.split("_")
+    return parts[0] + "".join(w.capitalize() for w in parts[1:])
+
+
+def _camel_keys(obj: Any, *, _depth: int = 0) -> Any:
+    """Convert dict keys from snake_case to camelCase, preserving row data as-is."""
+    if isinstance(obj, dict):
+        result: dict[str, Any] = {}
+        for k, v in obj.items():
+            new_key = _to_camel(k) if _depth < 2 else k
+            # Don't recurse into "rows" — that's user data
+            if new_key == "rows":
+                result[new_key] = v
+            else:
+                result[new_key] = _camel_keys(v, _depth=_depth + 1)
+        return result
+    if isinstance(obj, list):
+        return [_camel_keys(item, _depth=_depth) for item in obj]
+    return obj
+
+
+class DataExplorerExecuteRequest(BaseModel):
+    """Request body for executing a data explorer query."""
+
+    source: str
+    query: str
+    parameters: dict[str, Any] | None = None
+
+
+def create_data_explorer_router(
+    registry: DataExplorerRegistry,
+    executor: DataExplorerExecutor,
+) -> APIRouter:
+    """Create and return a FastAPI router with data-explorer endpoints."""
+    router = APIRouter()
+
+    @router.get("/sources")
+    async def get_sources() -> list[dict[str, Any]]:
+        return _camel_keys(registry.get_sources())
+
+    @router.post("/execute")
+    async def execute(request: DataExplorerExecuteRequest) -> dict[str, Any]:
+        result = await executor.execute_async(request.model_dump())
+        return _camel_keys(asdict(result))
+
+    @router.get("/schema")
+    async def get_schema(source: str) -> dict[str, Any]:
+        entry = registry.get(source)
+        if entry is None:
+            from fastapi import HTTPException
+            raise HTTPException(status_code=404, detail=f"Unknown data source: '{source}'")
+
+        provider, options = entry
+        schema = await provider.get_schema_async(options)
+        if schema is None:
+            from fastapi import HTTPException
+            raise HTTPException(status_code=404, detail="Schema introspection is not supported by this data source.")
+
+        return _camel_keys(asdict(schema))
+
+    return router

qodalis_cli_data_explorer/data_explorer_executor.py

@@ -0,0 +1,89 @@
+"""Executor that dispatches queries to the correct Data Explorer provider."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from qodalis_cli_server_abstractions import (
+    DataExplorerExecutionContext,
+    DataExplorerResult,
+)
+
+from .data_explorer_registry import DataExplorerRegistry
+
+
+class DataExplorerExecutor:
+    """Wraps provider execution with timeout enforcement and row truncation."""
+
+    def __init__(self, registry: DataExplorerRegistry) -> None:
+        self._registry = registry
+
+    async def execute_async(self, request: dict[str, Any]) -> DataExplorerResult:
+        """Execute a query against the appropriate provider with timeout enforcement."""
+        source = request.get("source", "")
+        query = request.get("query", "")
+        parameters = request.get("parameters") or {}
+
+        entry = self._registry.get(source)
+        if entry is None:
+            return DataExplorerResult(
+                success=False,
+                source=source,
+                language="sql",  # type: ignore[arg-type]
+                default_output_format="table",  # type: ignore[arg-type]
+                execution_time=0,
+                columns=None,
+                rows=[],
+                row_count=0,
+                truncated=False,
+                error=f"Unknown data source: {source}",
+            )
+
+        provider, options = entry
+        context = DataExplorerExecutionContext(
+            query=query,
+            parameters=parameters,
+            options=options,
+        )
+
+        timeout_s = options.timeout / 1000.0
+
+        try:
+            result = await asyncio.wait_for(
+                provider.execute_async(context),
+                timeout=timeout_s,
+            )
+        except asyncio.TimeoutError:
+            return DataExplorerResult(
+                success=False,
+                source=source,
+                language=options.language,
+                default_output_format=options.default_output_format,
+                execution_time=options.timeout,
+                columns=None,
+                rows=[],
+                row_count=0,
+                truncated=False,
+                error=f"Query timed out after {options.timeout}ms",
+            )
+        except Exception as exc:
+            return DataExplorerResult(
+                success=False,
+                source=source,
+                language=options.language,
+                default_output_format=options.default_output_format,
+                execution_time=0,
+                columns=None,
+                rows=[],
+                row_count=0,
+                truncated=False,
+                error=str(exc),
+            )
+
+        if result.row_count > options.max_rows:
+            result.rows = result.rows[: options.max_rows]
+            result.row_count = options.max_rows
+            result.truncated = True
+
+        return result

qodalis_cli_data_explorer/data_explorer_registry.py

@@ -0,0 +1,53 @@
+"""Registry for Data Explorer providers."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from typing import Any
+
+from qodalis_cli_server_abstractions import (
+    DataExplorerProviderOptions,
+    IDataExplorerProvider,
+)
+
+
+class _RegisteredProvider:
+    """Internal wrapper that pairs a provider with its options."""
+
+    __slots__ = ("provider", "options")
+
+    def __init__(
+        self,
+        provider: IDataExplorerProvider,
+        options: DataExplorerProviderOptions,
+    ) -> None:
+        self.provider = provider
+        self.options = options
+
+
+class DataExplorerRegistry:
+    """Stores :class:`IDataExplorerProvider` instances keyed by source name."""
+
+    def __init__(self) -> None:
+        self._providers: dict[str, _RegisteredProvider] = {}
+
+    def register(
+        self,
+        provider: IDataExplorerProvider,
+        options: DataExplorerProviderOptions,
+    ) -> None:
+        """Register a provider under the source name defined in *options*."""
+        self._providers[options.name] = _RegisteredProvider(provider, options)
+
+    def get(self, source: str) -> tuple[IDataExplorerProvider, DataExplorerProviderOptions] | None:
+        """Return the provider and its options for *source*, or ``None``."""
+        entry = self._providers.get(source)
+        if entry is None:
+            return None
+        return entry.provider, entry.options
+
+    def get_sources(self) -> list[dict[str, Any]]:
+        """Return a JSON-serialisable list of all registered sources."""
+        return [
+            asdict(entry.options) for entry in self._providers.values()
+        ]

qodalis_cli_server_plugin_data_explorer-1.0.0b13.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.5
+Name: qodalis-cli-server-plugin-data-explorer
+Version: 1.0.0b13
+Summary: Data Explorer plugin for Qodalis CLI servers
+Project-URL: Homepage, https://github.com/qodalis-solutions/cli-server-python
+Project-URL: Repository, https://github.com/qodalis-solutions/cli-server-python
+Project-URL: Issues, https://github.com/qodalis-solutions/cli-server-python/issues
+Author-email: Nicolae Lupei <nicolae.lupei@qodalis.com>
+License-Expression: MIT
+Keywords: cli,data-explorer,plugin,qodalis
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: qodalis-cli-server-abstractions

qodalis_cli_server_plugin_data_explorer-1.0.0b13.dist-info/RECORD

@@ -0,0 +1,7 @@
+qodalis_cli_data_explorer/__init__.py,sha256=QTGZKvJIxZtmbGWXO5v6FmW_v4l46kV9qVLDEI5xUYg,366
+qodalis_cli_data_explorer/data_explorer_controller.py,sha256=-2cncoZWRFivODr2iGhdu11AgPMPp_QyUkqpqxR1VUQ,2536
+qodalis_cli_data_explorer/data_explorer_executor.py,sha256=onzLBttxz1XXOFJxEu8X7FfpKB5AZg1SRgA6lD2mx7I,2898
+qodalis_cli_data_explorer/data_explorer_registry.py,sha256=a8tvUtMv7q9ndYuG9xYUM6ZNHnFTfXCOtSlfucFuzVg,1617
+qodalis_cli_server_plugin_data_explorer-1.0.0b13.dist-info/METADATA,sha256=qJshDto_0rtecR8hvs4us6IscBDY-qdWtBzBkdnz-58,965
+qodalis_cli_server_plugin_data_explorer-1.0.0b13.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+qodalis_cli_server_plugin_data_explorer-1.0.0b13.dist-info/RECORD,,

qodalis_cli_server_plugin_data_explorer-1.0.0b13.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any