lucidicai 2.1.3__tar.gz → 3.1.0__tar.gz

{lucidicai-2.1.3 → lucidicai-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lucidicai
-Version: 2.1.3
+Version: 3.1.0
 Summary: Lucidic AI Python SDK
 Author: Andy Liang
 Author-email: andy@lucidic.ai

lucidicai-3.1.0/lucidicai/__init__.py

@@ -0,0 +1,55 @@
+"""Lucidic AI SDK - Instance-based client for AI observability.
+
+This SDK provides observability for AI applications, tracking workflows,
+costs, and performance across multiple LLM providers.
+
+Example:
+    from lucidicai import LucidicAI
+
+    client = LucidicAI(api_key="...", agent_id="...", providers=["openai"])
+
+    with client.create_session(session_name="My Session") as session:
+        @client.event
+        def my_function():
+            # LLM calls are automatically tracked
+            pass
+        my_function()
+
+    client.close()
+"""
+
+# Main client class
+from .client import LucidicAI
+
+# Session object
+from .session_obj import Session
+
+# Error types
+from .core.errors import (
+    LucidicError,
+    LucidicNotInitializedError,
+    APIKeyVerificationError,
+    InvalidOperationError,
+    PromptError,
+    FeatureFlagError,
+)
+
+# Version
+__version__ = "3.1.0"
+
+# All exports
+__all__ = [
+    # Main client
+    "LucidicAI",
+    # Session object
+    "Session",
+    # Error types
+    "LucidicError",
+    "LucidicNotInitializedError",
+    "APIKeyVerificationError",
+    "InvalidOperationError",
+    "PromptError",
+    "FeatureFlagError",
+    # Version
+    "__version__",
+]

{lucidicai-2.1.3 → lucidicai-3.1.0}/lucidicai/api/client.py

@@ -43,6 +43,7 @@ class HttpClient:
         # Lazy-initialized clients
         self._sync_client: Optional[httpx.Client] = None
         self._async_client: Optional[httpx.AsyncClient] = None
+        self._async_client_loop: Optional[asyncio.AbstractEventLoop] = None
     
     def _build_headers(self) -> Dict[str, str]:
         """Build default headers for requests."""
@@ -75,8 +76,34 @@ class HttpClient:
     
     @property
     def async_client(self) -> httpx.AsyncClient:
-        """Get or create the asynchronous HTTP client."""
-        if self._async_client is None or self._async_client.is_closed:
+        """Get or create the asynchronous HTTP client.
+        
+        The client is recreated if the event loop has changed, since
+        httpx.AsyncClient is tied to a specific event loop.
+        """
+        # Check if we need to recreate the client
+        current_loop = None
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            pass  # No running loop
+        
+        # Recreate client if: no client, client closed, or event loop changed
+        needs_new_client = (
+            self._async_client is None or 
+            self._async_client.is_closed or
+            (current_loop is not None and self._async_client_loop is not current_loop)
+        )
+        
+        if needs_new_client:
+            # Close old client if it exists and isn't already closed
+            if self._async_client is not None and not self._async_client.is_closed:
+                try:
+                    # Can't await in a property, so we just let it be garbage collected
+                    pass
+                except Exception:
+                    pass
+            
             transport = httpx.AsyncHTTPTransport(**self._transport_kwargs)
             self._async_client = httpx.AsyncClient(
                 base_url=self.base_url,
@@ -85,6 +112,8 @@ class HttpClient:
                 limits=self._limits,
                 transport=transport,
             )
+            self._async_client_loop = current_loop
+            
         return self._async_client
     
     def _add_timestamp(self, data: Optional[Dict[str, Any]]) -> Dict[str, Any]:

lucidicai-3.1.0/lucidicai/api/resources/__init__.py

@@ -0,0 +1,16 @@
+"""API resource modules."""
+from .session import SessionResource
+from .event import EventResource
+from .dataset import DatasetResource
+from .experiment import ExperimentResource
+from .prompt import PromptResource
+from .feature_flag import FeatureFlagResource
+
+__all__ = [
+    "SessionResource",
+    "EventResource",
+    "DatasetResource",
+    "ExperimentResource",
+    "PromptResource",
+    "FeatureFlagResource",
+]

lucidicai-3.1.0/lucidicai/api/resources/dataset.py

@@ -0,0 +1,532 @@
+"""Dataset resource API operations."""
+import logging
+from typing import Any, Dict, List, Optional
+
+from ..client import HttpClient
+
+logger = logging.getLogger("Lucidic")
+
+
+class DatasetResource:
+    """Handle dataset-related API operations."""
+
+    def __init__(
+        self,
+        http: HttpClient,
+        agent_id: Optional[str] = None,
+        production: bool = False,
+    ):
+        """Initialize dataset resource.
+
+        Args:
+            http: HTTP client instance
+            agent_id: Default agent ID for datasets
+            production: Whether to suppress errors in production mode
+        """
+        self.http = http
+        self._agent_id = agent_id
+        self._production = production
+
+    # ==================== Dataset Methods ====================
+
+    def list(self, agent_id: Optional[str] = None) -> Dict[str, Any]:
+        """List all datasets for agent.
+
+        Args:
+            agent_id: Optional agent ID to filter by (uses default if not provided)
+
+        Returns:
+            Dictionary with num_datasets and datasets list
+        """
+        try:
+            params = {}
+            if agent_id or self._agent_id:
+                params["agent_id"] = agent_id or self._agent_id
+            return self.http.get("sdk/datasets", params)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to list datasets: {e}")
+                return {"num_datasets": 0, "datasets": []}
+            raise
+
+    def create(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        suggested_flag_config: Optional[Dict[str, Any]] = None,
+        agent_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create new dataset.
+
+        Args:
+            name: Dataset name (must be unique per agent)
+            description: Optional description
+            tags: Optional list of tags
+            suggested_flag_config: Optional flag configuration
+            agent_id: Optional agent ID (uses default if not provided)
+
+        Returns:
+            Dictionary with dataset_id
+        """
+        try:
+            data: Dict[str, Any] = {"name": name}
+            if description is not None:
+                data["description"] = description
+            if tags is not None:
+                data["tags"] = tags
+            if suggested_flag_config is not None:
+                data["suggested_flag_config"] = suggested_flag_config
+            data["agent_id"] = agent_id or self._agent_id
+            return self.http.post("sdk/datasets/create", data)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to create dataset: {e}")
+                return {}
+            raise
+
+    def get(self, dataset_id: str) -> Dict[str, Any]:
+        """Get dataset with all items.
+
+        Args:
+            dataset_id: Dataset UUID
+
+        Returns:
+            Full dataset data including all items
+        """
+        try:
+            return self.http.get("getdataset", {"dataset_id": dataset_id})
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to get dataset: {e}")
+                return {}
+            raise
+
+    def update(self, dataset_id: str, **kwargs) -> Dict[str, Any]:
+        """Update dataset metadata.
+
+        Args:
+            dataset_id: Dataset UUID
+            **kwargs: Fields to update (name, description, tags, suggested_flag_config)
+
+        Returns:
+            Updated dataset data
+        """
+        try:
+            data = {"dataset_id": dataset_id}
+            data.update(kwargs)
+            return self.http.put("sdk/datasets/update", data)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to update dataset: {e}")
+                return {}
+            raise
+
+    def delete(self, dataset_id: str) -> Dict[str, Any]:
+        """Delete dataset and all items.
+
+        Args:
+            dataset_id: Dataset UUID
+
+        Returns:
+            Success message
+        """
+        try:
+            return self.http.delete("sdk/datasets/delete", {"dataset_id": dataset_id})
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to delete dataset: {e}")
+                return {}
+            raise
+
+    # ==================== Dataset Item Methods ====================
+
+    def create_item(
+        self,
+        dataset_id: str,
+        name: str,
+        input_data: Dict[str, Any],
+        expected_output: Optional[Any] = None,
+        description: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        flag_overrides: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Create dataset item.
+
+        Args:
+            dataset_id: Dataset UUID
+            name: Item name
+            input_data: Input data dictionary
+            expected_output: Optional expected output
+            description: Optional description
+            tags: Optional list of tags
+            metadata: Optional metadata dictionary
+            flag_overrides: Optional flag overrides
+
+        Returns:
+            Dictionary with datasetitem_id
+        """
+        try:
+            data: Dict[str, Any] = {
+                "dataset_id": dataset_id,
+                "name": name,
+                "input": input_data
+            }
+
+            if expected_output is not None:
+                data["expected_output"] = expected_output
+            if description is not None:
+                data["description"] = description
+            if tags is not None:
+                data["tags"] = tags
+            if metadata is not None:
+                data["metadata"] = metadata
+            if flag_overrides is not None:
+                data["flag_overrides"] = flag_overrides
+
+            return self.http.post("sdk/datasets/items/create", data)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to create item: {e}")
+                return {}
+            raise
+
+    def get_item(self, dataset_id: str, item_id: str) -> Dict[str, Any]:
+        """Get specific dataset item.
+
+        Args:
+            dataset_id: Dataset UUID
+            item_id: Item UUID
+
+        Returns:
+            Dataset item data
+        """
+        try:
+            return self.http.get("sdk/datasets/items/get", {
+                "dataset_id": dataset_id,
+                "datasetitem_id": item_id
+            })
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to get item: {e}")
+                return {}
+            raise
+
+    def update_item(self, dataset_id: str, item_id: str, **kwargs) -> Dict[str, Any]:
+        """Update dataset item.
+
+        Args:
+            dataset_id: Dataset UUID
+            item_id: Item UUID
+            **kwargs: Fields to update
+
+        Returns:
+            Updated item data
+        """
+        try:
+            data = {
+                "dataset_id": dataset_id,
+                "datasetitem_id": item_id
+            }
+            data.update(kwargs)
+            return self.http.put("sdk/datasets/items/update", data)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to update item: {e}")
+                return {}
+            raise
+
+    def delete_item(self, dataset_id: str, item_id: str) -> Dict[str, Any]:
+        """Delete dataset item.
+
+        Args:
+            dataset_id: Dataset UUID
+            item_id: Item UUID
+
+        Returns:
+            Success message
+        """
+        try:
+            return self.http.delete("sdk/datasets/items/delete", {
+                "dataset_id": dataset_id,
+                "datasetitem_id": item_id
+            })
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to delete item: {e}")
+                return {}
+            raise
+
+    def list_item_sessions(self, dataset_id: str, item_id: str) -> Dict[str, Any]:
+        """List all sessions for a dataset item.
+
+        Args:
+            dataset_id: Dataset UUID
+            item_id: Item UUID
+
+        Returns:
+            Dictionary with num_sessions and sessions list
+        """
+        try:
+            return self.http.get("sdk/datasets/items/sessions", {
+                "dataset_id": dataset_id,
+                "datasetitem_id": item_id
+            })
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to list item sessions: {e}")
+                return {"num_sessions": 0, "sessions": []}
+            raise
+
+    # ==================== Asynchronous Dataset Methods ====================
+
+    async def alist(self, agent_id: Optional[str] = None) -> Dict[str, Any]:
+        """List all datasets for agent (asynchronous).
+
+        Args:
+            agent_id: Optional agent ID to filter by (uses default if not provided)
+
+        Returns:
+            Dictionary with num_datasets and datasets list
+        """
+        try:
+            params = {}
+            if agent_id or self._agent_id:
+                params["agent_id"] = agent_id or self._agent_id
+            return await self.http.aget("sdk/datasets", params)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to list datasets: {e}")
+                return {"num_datasets": 0, "datasets": []}
+            raise
+
+    async def acreate(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        suggested_flag_config: Optional[Dict[str, Any]] = None,
+        agent_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create new dataset (asynchronous).
+
+        Args:
+            name: Dataset name (must be unique per agent)
+            description: Optional description
+            tags: Optional list of tags
+            suggested_flag_config: Optional flag configuration
+            agent_id: Optional agent ID (uses default if not provided)
+
+        Returns:
+            Dictionary with dataset_id
+        """
+        try:
+            data: Dict[str, Any] = {"name": name}
+            if description is not None:
+                data["description"] = description
+            if tags is not None:
+                data["tags"] = tags
+            if suggested_flag_config is not None:
+                data["suggested_flag_config"] = suggested_flag_config
+            data["agent_id"] = agent_id or self._agent_id
+            return await self.http.apost("sdk/datasets/create", data)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to create dataset: {e}")
+                return {}
+            raise
+
+    async def aget(self, dataset_id: str) -> Dict[str, Any]:
+        """Get dataset with all items (asynchronous).
+
+        Args:
+            dataset_id: Dataset UUID
+
+        Returns:
+            Full dataset data including all items
+        """
+        try:
+            return await self.http.aget("getdataset", {"dataset_id": dataset_id})
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to get dataset: {e}")
+                return {}
+            raise
+
+    async def aupdate(self, dataset_id: str, **kwargs) -> Dict[str, Any]:
+        """Update dataset metadata (asynchronous).
+
+        Args:
+            dataset_id: Dataset UUID
+            **kwargs: Fields to update (name, description, tags, suggested_flag_config)
+
+        Returns:
+            Updated dataset data
+        """
+        try:
+            data = {"dataset_id": dataset_id}
+            data.update(kwargs)
+            return await self.http.aput("sdk/datasets/update", data)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to update dataset: {e}")
+                return {}
+            raise
+
+    async def adelete(self, dataset_id: str) -> Dict[str, Any]:
+        """Delete dataset and all items (asynchronous).
+
+        Args:
+            dataset_id: Dataset UUID
+
+        Returns:
+            Success message
+        """
+        try:
+            return await self.http.adelete("sdk/datasets/delete", {"dataset_id": dataset_id})
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to delete dataset: {e}")
+                return {}
+            raise
+
+    # ==================== Asynchronous Item Methods ====================
+
+    async def acreate_item(
+        self,
+        dataset_id: str,
+        name: str,
+        input_data: Dict[str, Any],
+        expected_output: Optional[Any] = None,
+        description: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        flag_overrides: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Create dataset item (asynchronous).
+
+        Args:
+            dataset_id: Dataset UUID
+            name: Item name
+            input_data: Input data dictionary
+            expected_output: Optional expected output
+            description: Optional description
+            tags: Optional list of tags
+            metadata: Optional metadata dictionary
+            flag_overrides: Optional flag overrides
+
+        Returns:
+            Dictionary with datasetitem_id
+        """
+        try:
+            data: Dict[str, Any] = {
+                "dataset_id": dataset_id,
+                "name": name,
+                "input": input_data
+            }
+
+            if expected_output is not None:
+                data["expected_output"] = expected_output
+            if description is not None:
+                data["description"] = description
+            if tags is not None:
+                data["tags"] = tags
+            if metadata is not None:
+                data["metadata"] = metadata
+            if flag_overrides is not None:
+                data["flag_overrides"] = flag_overrides
+
+            return await self.http.apost("sdk/datasets/items/create", data)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to create item: {e}")
+                return {}
+            raise
+
+    async def aget_item(self, dataset_id: str, item_id: str) -> Dict[str, Any]:
+        """Get specific dataset item (asynchronous).
+
+        Args:
+            dataset_id: Dataset UUID
+            item_id: Item UUID
+
+        Returns:
+            Dataset item data
+        """
+        try:
+            return await self.http.aget("sdk/datasets/items/get", {
+                "dataset_id": dataset_id,
+                "datasetitem_id": item_id
+            })
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to get item: {e}")
+                return {}
+            raise
+
+    async def aupdate_item(self, dataset_id: str, item_id: str, **kwargs) -> Dict[str, Any]:
+        """Update dataset item (asynchronous).
+
+        Args:
+            dataset_id: Dataset UUID
+            item_id: Item UUID
+            **kwargs: Fields to update
+
+        Returns:
+            Updated item data
+        """
+        try:
+            data = {
+                "dataset_id": dataset_id,
+                "datasetitem_id": item_id
+            }
+            data.update(kwargs)
+            return await self.http.aput("sdk/datasets/items/update", data)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to update item: {e}")
+                return {}
+            raise
+
+    async def adelete_item(self, dataset_id: str, item_id: str) -> Dict[str, Any]:
+        """Delete dataset item (asynchronous).
+
+        Args:
+            dataset_id: Dataset UUID
+            item_id: Item UUID
+
+        Returns:
+            Success message
+        """
+        try:
+            return await self.http.adelete("sdk/datasets/items/delete", {
+                "dataset_id": dataset_id,
+                "datasetitem_id": item_id
+            })
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to delete item: {e}")
+                return {}
+            raise
+
+    async def alist_item_sessions(self, dataset_id: str, item_id: str) -> Dict[str, Any]:
+        """List all sessions for a dataset item (asynchronous).
+
+        Args:
+            dataset_id: Dataset UUID
+            item_id: Item UUID
+
+        Returns:
+            Dictionary with num_sessions and sessions list
+        """
+        try:
+            return await self.http.aget("sdk/datasets/items/sessions", {
+                "dataset_id": dataset_id,
+                "datasetitem_id": item_id
+            })
+        except Exception as e:
+            if self._production:
+                logger.error(f"[DatasetResource] Failed to list item sessions: {e}")
+                return {"num_sessions": 0, "sessions": []}
+            raise