lucidicai 2.1.2__tar.gz → 2.1.3__tar.gz

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

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

{lucidicai-2.1.2 → lucidicai-2.1.3}/lucidicai/__init__.py

@@ -297,7 +297,7 @@ get_error_history = error_boundary.get_error_history
 clear_error_history = error_boundary.clear_error_history
 
 # Version
-__version__ = "2.1.2"
+__version__ = "2.1.3"
 
 # Apply error boundary wrapping to all SDK functions
 from .sdk.error_boundary import wrap_sdk_function

lucidicai-2.1.3/lucidicai/api/client.py

@@ -0,0 +1,357 @@
+"""Pure HTTP client for Lucidic API communication.
+
+This module contains only the HTTP client logic using httpx,
+supporting both synchronous and asynchronous operations.
+"""
+import asyncio
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ..core.config import SDKConfig, get_config
+from ..core.errors import APIKeyVerificationError
+from ..utils.logger import debug, info, warning, error, mask_sensitive, truncate_data
+
+
+class HttpClient:
+    """HTTP client for API communication with sync and async support."""
+    
+    def __init__(self, config: Optional[SDKConfig] = None):
+        """Initialize the HTTP client.
+        
+        Args:
+            config: SDK configuration (uses global if not provided)
+        """
+        self.config = config or get_config()
+        self.base_url = self.config.network.base_url
+        
+        # Build default headers
+        self._headers = self._build_headers()
+        
+        # Transport configuration for connection pooling and retries
+        self._transport_kwargs = {
+            "retries": self.config.network.max_retries,
+        }
+        
+        # Connection limits for pooling
+        self._limits = httpx.Limits(
+            max_connections=self.config.network.connection_pool_maxsize,
+            max_keepalive_connections=self.config.network.connection_pool_size,
+        )
+        
+        # Lazy-initialized clients
+        self._sync_client: Optional[httpx.Client] = None
+        self._async_client: Optional[httpx.AsyncClient] = None
+    
+    def _build_headers(self) -> Dict[str, str]:
+        """Build default headers for requests."""
+        headers = {
+            "User-Agent": "lucidic-sdk/2.0",
+            "Content-Type": "application/json"
+        }
+        
+        if self.config.api_key:
+            headers["Authorization"] = f"Api-Key {self.config.api_key}"
+        
+        if self.config.agent_id:
+            headers["x-agent-id"] = self.config.agent_id
+        
+        return headers
+    
+    @property
+    def sync_client(self) -> httpx.Client:
+        """Get or create the synchronous HTTP client."""
+        if self._sync_client is None or self._sync_client.is_closed:
+            transport = httpx.HTTPTransport(**self._transport_kwargs)
+            self._sync_client = httpx.Client(
+                base_url=self.base_url,
+                headers=self._headers,
+                timeout=httpx.Timeout(self.config.network.timeout),
+                limits=self._limits,
+                transport=transport,
+            )
+        return self._sync_client
+    
+    @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:
+            transport = httpx.AsyncHTTPTransport(**self._transport_kwargs)
+            self._async_client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers=self._headers,
+                timeout=httpx.Timeout(self.config.network.timeout),
+                limits=self._limits,
+                transport=transport,
+            )
+        return self._async_client
+    
+    def _add_timestamp(self, data: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+        """Add current_time to request data."""
+        if data is None:
+            data = {}
+        data["current_time"] = datetime.now(timezone.utc).isoformat()
+        return data
+    
+    def _handle_response(self, response: httpx.Response) -> Dict[str, Any]:
+        """Handle HTTP response and parse JSON.
+        
+        Args:
+            response: httpx Response object
+            
+        Returns:
+            Response data as dictionary
+            
+        Raises:
+            APIKeyVerificationError: On 401 Unauthorized responses
+            httpx.HTTPStatusError: On other HTTP errors
+        """
+        # Log and raise for HTTP errors
+        if not response.is_success:
+            try:
+                error_data = response.json()
+                error_msg = error_data.get('detail', response.text)
+            except Exception:
+                error_msg = response.text
+            
+            error(f"[HTTP] Error {response.status_code}: {error_msg}")
+            
+            # Raise specific error for authentication/authorization failures
+            if response.status_code in (401, 403):
+                raise APIKeyVerificationError(f"Authentication failed: {error_msg}")
+        
+        response.raise_for_status()
+        
+        # Parse JSON response
+        try:
+            data = response.json()
+        except ValueError:
+            # For empty responses (like verifyapikey), return success
+            if response.status_code == 200 and not response.text:
+                data = {"success": True}
+            else:
+                # Return text if not JSON
+                data = {"response": response.text}
+        
+        debug(f"[HTTP] Response ({response.status_code}): {truncate_data(data)}")
+        
+        return data
+    
+    # ==================== Synchronous Methods ====================
+    
+    def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a synchronous GET request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            params: Query parameters
+            
+        Returns:
+            Response data as dictionary
+        """
+        return self.request("GET", endpoint, params=params)
+    
+    def post(self, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a synchronous POST request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            data: Request body data
+            
+        Returns:
+            Response data as dictionary
+        """
+        data = self._add_timestamp(data)
+        return self.request("POST", endpoint, json=data)
+    
+    def put(self, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a synchronous PUT request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            data: Request body data
+            
+        Returns:
+            Response data as dictionary
+        """
+        data = self._add_timestamp(data)
+        return self.request("PUT", endpoint, json=data)
+    
+    def delete(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a synchronous DELETE request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            params: Query parameters
+            
+        Returns:
+            Response data as dictionary
+        """
+        return self.request("DELETE", endpoint, params=params)
+    
+    def request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Make a synchronous HTTP request.
+        
+        Args:
+            method: HTTP method
+            endpoint: API endpoint (without base URL)
+            params: Query parameters
+            json: Request body (for POST/PUT)
+            **kwargs: Additional arguments for httpx
+            
+        Returns:
+            Response data as dictionary
+            
+        Raises:
+            httpx.HTTPError: On HTTP errors
+        """
+        url = f"/{endpoint}"
+        
+        # Log request details
+        debug(f"[HTTP] {method} {self.base_url}{url}")
+        if params:
+            debug(f"[HTTP] Query params: {mask_sensitive(params)}")
+        if json:
+            debug(f"[HTTP] Request body: {truncate_data(mask_sensitive(json))}")
+        
+        response = self.sync_client.request(
+            method=method,
+            url=url,
+            params=params,
+            json=json,
+            **kwargs
+        )
+        
+        return self._handle_response(response)
+    
+    # ==================== Asynchronous Methods ====================
+    
+    async def aget(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an asynchronous GET request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            params: Query parameters
+            
+        Returns:
+            Response data as dictionary
+        """
+        return await self.arequest("GET", endpoint, params=params)
+    
+    async def apost(self, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an asynchronous POST request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            data: Request body data
+            
+        Returns:
+            Response data as dictionary
+        """
+        data = self._add_timestamp(data)
+        return await self.arequest("POST", endpoint, json=data)
+    
+    async def aput(self, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an asynchronous PUT request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            data: Request body data
+            
+        Returns:
+            Response data as dictionary
+        """
+        data = self._add_timestamp(data)
+        return await self.arequest("PUT", endpoint, json=data)
+    
+    async def adelete(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an asynchronous DELETE request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            params: Query parameters
+            
+        Returns:
+            Response data as dictionary
+        """
+        return await self.arequest("DELETE", endpoint, params=params)
+    
+    async def arequest(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Make an asynchronous HTTP request.
+        
+        Args:
+            method: HTTP method
+            endpoint: API endpoint (without base URL)
+            params: Query parameters
+            json: Request body (for POST/PUT)
+            **kwargs: Additional arguments for httpx
+            
+        Returns:
+            Response data as dictionary
+            
+        Raises:
+            httpx.HTTPError: On HTTP errors
+        """
+        url = f"/{endpoint}"
+        
+        # Log request details
+        debug(f"[HTTP] {method} {self.base_url}{url}")
+        if params:
+            debug(f"[HTTP] Query params: {mask_sensitive(params)}")
+        if json:
+            debug(f"[HTTP] Request body: {truncate_data(mask_sensitive(json))}")
+        
+        response = await self.async_client.request(
+            method=method,
+            url=url,
+            params=params,
+            json=json,
+            **kwargs
+        )
+        
+        return self._handle_response(response)
+    
+    # ==================== Lifecycle Methods ====================
+    
+    def close(self) -> None:
+        """Close the synchronous HTTP client."""
+        if self._sync_client is not None and not self._sync_client.is_closed:
+            self._sync_client.close()
+            self._sync_client = None
+    
+    async def aclose(self) -> None:
+        """Close the asynchronous HTTP client."""
+        if self._async_client is not None and not self._async_client.is_closed:
+            await self._async_client.aclose()
+            self._async_client = None
+    
+    def __enter__(self) -> "HttpClient":
+        """Context manager entry for sync client."""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Context manager exit for sync client."""
+        self.close()
+    
+    async def __aenter__(self) -> "HttpClient":
+        """Async context manager entry."""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Async context manager exit."""
+        await self.aclose()

{lucidicai-2.1.2 → lucidicai-2.1.3}/lucidicai/sdk/features/dataset.py

@@ -1,9 +1,5 @@
-import os
 import logging
 from typing import Optional, Dict, List, Any
-from dotenv import load_dotenv
-
-from ...core.errors import APIKeyVerificationError
 
 logger = logging.getLogger("Lucidic")
 
@@ -36,37 +32,15 @@ def get_dataset(
         APIKeyVerificationError: If API key or agent ID is missing or invalid.
         ValueError: If dataset_id is not provided.
     """
-    load_dotenv()
-    
     # Validation
     if not dataset_id:
         raise ValueError("Dataset ID is required")
     
-    # Get credentials
-    if api_key is None:
-        api_key = os.getenv("LUCIDIC_API_KEY", None)
-        if api_key is None:
-            raise APIKeyVerificationError(
-                "Make sure to either pass your API key into get_dataset() or set the LUCIDIC_API_KEY environment variable."
-            )
-    
-    if agent_id is None:
-        agent_id = os.getenv("LUCIDIC_AGENT_ID", None)
-        if agent_id is None:
-            raise APIKeyVerificationError(
-                "Lucidic agent ID not specified. Make sure to either pass your agent ID into get_dataset() or set the LUCIDIC_AGENT_ID environment variable."
-            )
-    
-    # Get HTTP client
-    from ..init import get_http
-    from ...core.config import SDKConfig
-    from ...api.client import HttpClient
+    from ..init import ensure_http_and_resources, get_http
     
+    # Ensure HTTP client is initialized and stored in SDK state
+    ensure_http_and_resources(api_key=api_key, agent_id=agent_id)
     http = get_http()
-    if not http:
-        # Create a new HTTP client if needed
-        config = SDKConfig.from_env(api_key=api_key, agent_id=agent_id)
-        http = HttpClient(config)
     
     # Make request to get dataset
     response = http.get('getdataset', {'dataset_id': dataset_id})
@@ -126,31 +100,9 @@ def list_datasets(
     Raises:
         APIKeyVerificationError: If API key or agent ID is missing or invalid.
     """
-    from ..init import get_resources, get_http
-    from ...core.config import SDKConfig
-    from ...api.client import HttpClient
-
-    # Get or create resources
-    resources = get_resources()
-    if not resources or 'datasets' not in resources:
-        load_dotenv()
-
-        # Get credentials
-        if api_key is None:
-            api_key = os.getenv("LUCIDIC_API_KEY", None)
-            if api_key is None:
-                raise APIKeyVerificationError(
-                    "Make sure to either pass your API key or set the LUCIDIC_API_KEY environment variable."
-                )
-
-        if agent_id is None:
-            agent_id = os.getenv("LUCIDIC_AGENT_ID", None)
-
-        config = SDKConfig.from_env(api_key=api_key, agent_id=agent_id)
-        http = HttpClient(config)
-        from ...api.resources.dataset import DatasetResource
-        resources = {'datasets': DatasetResource(http)}
+    from ..init import ensure_http_and_resources
 
+    resources = ensure_http_and_resources(api_key=api_key, agent_id=agent_id)
     return resources['datasets'].list_datasets(agent_id)
 
 
@@ -179,30 +131,9 @@ def create_dataset(
     Raises:
         APIKeyVerificationError: If API key or agent ID is missing or invalid.
     """
-    from ..init import get_resources, get_http
-    from ...core.config import SDKConfig
-    from ...api.client import HttpClient
-
-    # Get or create resources
-    resources = get_resources()
-    if not resources or 'datasets' not in resources:
-        load_dotenv()
-
-        if api_key is None:
-            api_key = os.getenv("LUCIDIC_API_KEY", None)
-            if api_key is None:
-                raise APIKeyVerificationError(
-                    "Make sure to either pass your API key or set the LUCIDIC_API_KEY environment variable."
-                )
-
-        if agent_id is None:
-            agent_id = os.getenv("LUCIDIC_AGENT_ID", None)
-
-        config = SDKConfig.from_env(api_key=api_key, agent_id=agent_id)
-        http = HttpClient(config)
-        from ...api.resources.dataset import DatasetResource
-        resources = {'datasets': DatasetResource(http)}
+    from ..init import ensure_http_and_resources
 
+    resources = ensure_http_and_resources(api_key=api_key, agent_id=agent_id)
     return resources['datasets'].create_dataset(name, description, tags, suggested_flag_config, agent_id)
 
 
@@ -233,29 +164,9 @@ def update_dataset(
     Raises:
         APIKeyVerificationError: If API key or agent ID is missing or invalid.
     """
-    from ..init import get_resources, get_http
-    from ...core.config import SDKConfig
-    from ...api.client import HttpClient
-
-    # Get or create resources
-    resources = get_resources()
-    if not resources or 'datasets' not in resources:
-        load_dotenv()
-
-        if api_key is None:
-            api_key = os.getenv("LUCIDIC_API_KEY", None)
-            if api_key is None:
-                raise APIKeyVerificationError(
-                    "Make sure to either pass your API key or set the LUCIDIC_API_KEY environment variable."
-                )
-
-        if agent_id is None:
-            agent_id = os.getenv("LUCIDIC_AGENT_ID", None)
-
-        config = SDKConfig.from_env(api_key=api_key, agent_id=agent_id)
-        http = HttpClient(config)
-        from ...api.resources.dataset import DatasetResource
-        resources = {'datasets': DatasetResource(http)}
+    from ..init import ensure_http_and_resources
+
+    resources = ensure_http_and_resources(api_key=api_key, agent_id=agent_id)
 
     kwargs = {}
     if name is not None:
@@ -289,30 +200,9 @@ def delete_dataset(
     Raises:
         APIKeyVerificationError: If API key or agent ID is missing or invalid.
     """
-    from ..init import get_resources, get_http
-    from ...core.config import SDKConfig
-    from ...api.client import HttpClient
-
-    # Get or create resources
-    resources = get_resources()
-    if not resources or 'datasets' not in resources:
-        load_dotenv()
-
-        if api_key is None:
-            api_key = os.getenv("LUCIDIC_API_KEY", None)
-            if api_key is None:
-                raise APIKeyVerificationError(
-                    "Make sure to either pass your API key or set the LUCIDIC_API_KEY environment variable."
-                )
-
-        if agent_id is None:
-            agent_id = os.getenv("LUCIDIC_AGENT_ID", None)
-
-        config = SDKConfig.from_env(api_key=api_key, agent_id=agent_id)
-        http = HttpClient(config)
-        from ...api.resources.dataset import DatasetResource
-        resources = {'datasets': DatasetResource(http)}
+    from ..init import ensure_http_and_resources
 
+    resources = ensure_http_and_resources(api_key=api_key, agent_id=agent_id)
     return resources['datasets'].delete_dataset(dataset_id)
 
 
@@ -349,30 +239,9 @@ def create_dataset_item(
     Raises:
         APIKeyVerificationError: If API key or agent ID is missing or invalid.
     """
-    from ..init import get_resources, get_http
-    from ...core.config import SDKConfig
-    from ...api.client import HttpClient
-
-    # Get or create resources
-    resources = get_resources()
-    if not resources or 'datasets' not in resources:
-        load_dotenv()
-
-        if api_key is None:
-            api_key = os.getenv("LUCIDIC_API_KEY", None)
-            if api_key is None:
-                raise APIKeyVerificationError(
-                    "Make sure to either pass your API key or set the LUCIDIC_API_KEY environment variable."
-                )
-
-        if agent_id is None:
-            agent_id = os.getenv("LUCIDIC_AGENT_ID", None)
-
-        config = SDKConfig.from_env(api_key=api_key, agent_id=agent_id)
-        http = HttpClient(config)
-        from ...api.resources.dataset import DatasetResource
-        resources = {'datasets': DatasetResource(http)}
+    from ..init import ensure_http_and_resources
 
+    resources = ensure_http_and_resources(api_key=api_key, agent_id=agent_id)
     return resources['datasets'].create_item(
         dataset_id, name, input_data,
         expected_output=expected_output,
@@ -404,30 +273,9 @@ def get_dataset_item(
     Raises:
         APIKeyVerificationError: If API key or agent ID is missing or invalid.
     """
-    from ..init import get_resources, get_http
-    from ...core.config import SDKConfig
-    from ...api.client import HttpClient
-
-    # Get or create resources
-    resources = get_resources()
-    if not resources or 'datasets' not in resources:
-        load_dotenv()
-
-        if api_key is None:
-            api_key = os.getenv("LUCIDIC_API_KEY", None)
-            if api_key is None:
-                raise APIKeyVerificationError(
-                    "Make sure to either pass your API key or set the LUCIDIC_API_KEY environment variable."
-                )
-
-        if agent_id is None:
-            agent_id = os.getenv("LUCIDIC_AGENT_ID", None)
-
-        config = SDKConfig.from_env(api_key=api_key, agent_id=agent_id)
-        http = HttpClient(config)
-        from ...api.resources.dataset import DatasetResource
-        resources = {'datasets': DatasetResource(http)}
+    from ..init import ensure_http_and_resources
 
+    resources = ensure_http_and_resources(api_key=api_key, agent_id=agent_id)
     return resources['datasets'].get_item(dataset_id, item_id)
 
 
@@ -466,29 +314,9 @@ def update_dataset_item(
     Raises:
         APIKeyVerificationError: If API key or agent ID is missing or invalid.
     """
-    from ..init import get_resources, get_http
-    from ...core.config import SDKConfig
-    from ...api.client import HttpClient
-
-    # Get or create resources
-    resources = get_resources()
-    if not resources or 'datasets' not in resources:
-        load_dotenv()
-
-        if api_key is None:
-            api_key = os.getenv("LUCIDIC_API_KEY", None)
-            if api_key is None:
-                raise APIKeyVerificationError(
-                    "Make sure to either pass your API key or set the LUCIDIC_API_KEY environment variable."
-                )
-
-        if agent_id is None:
-            agent_id = os.getenv("LUCIDIC_AGENT_ID", None)
-
-        config = SDKConfig.from_env(api_key=api_key, agent_id=agent_id)
-        http = HttpClient(config)
-        from ...api.resources.dataset import DatasetResource
-        resources = {'datasets': DatasetResource(http)}
+    from ..init import ensure_http_and_resources
+
+    resources = ensure_http_and_resources(api_key=api_key, agent_id=agent_id)
 
     kwargs = {}
     if name is not None:
@@ -530,30 +358,9 @@ def delete_dataset_item(
     Raises:
         APIKeyVerificationError: If API key or agent ID is missing or invalid.
     """
-    from ..init import get_resources, get_http
-    from ...core.config import SDKConfig
-    from ...api.client import HttpClient
-
-    # Get or create resources
-    resources = get_resources()
-    if not resources or 'datasets' not in resources:
-        load_dotenv()
-
-        if api_key is None:
-            api_key = os.getenv("LUCIDIC_API_KEY", None)
-            if api_key is None:
-                raise APIKeyVerificationError(
-                    "Make sure to either pass your API key or set the LUCIDIC_API_KEY environment variable."
-                )
-
-        if agent_id is None:
-            agent_id = os.getenv("LUCIDIC_AGENT_ID", None)
-
-        config = SDKConfig.from_env(api_key=api_key, agent_id=agent_id)
-        http = HttpClient(config)
-        from ...api.resources.dataset import DatasetResource
-        resources = {'datasets': DatasetResource(http)}
+    from ..init import ensure_http_and_resources
 
+    resources = ensure_http_and_resources(api_key=api_key, agent_id=agent_id)
     return resources['datasets'].delete_item(dataset_id, item_id)
 
 
@@ -578,28 +385,7 @@ def list_dataset_item_sessions(
     Raises:
         APIKeyVerificationError: If API key or agent ID is missing or invalid.
     """
-    from ..init import get_resources, get_http
-    from ...core.config import SDKConfig
-    from ...api.client import HttpClient
-
-    # Get or create resources
-    resources = get_resources()
-    if not resources or 'datasets' not in resources:
-        load_dotenv()
-
-        if api_key is None:
-            api_key = os.getenv("LUCIDIC_API_KEY", None)
-            if api_key is None:
-                raise APIKeyVerificationError(
-                    "Make sure to either pass your API key or set the LUCIDIC_API_KEY environment variable."
-                )
-
-        if agent_id is None:
-            agent_id = os.getenv("LUCIDIC_AGENT_ID", None)
-
-        config = SDKConfig.from_env(api_key=api_key, agent_id=agent_id)
-        http = HttpClient(config)
-        from ...api.resources.dataset import DatasetResource
-        resources = {'datasets': DatasetResource(http)}
+    from ..init import ensure_http_and_resources
 
+    resources = ensure_http_and_resources(api_key=api_key, agent_id=agent_id)
     return resources['datasets'].list_item_sessions(dataset_id, item_id)

{lucidicai-2.1.2 → lucidicai-2.1.3}/lucidicai/sdk/init.py

@@ -353,6 +353,75 @@ def get_resources() -> dict:
     return _sdk_state.resources
 
 
+def set_http(http: HttpClient) -> None:
+    """Set the HTTP client instance in SDK state."""
+    global _sdk_state
+    _sdk_state.http = http
+
+
+def set_resources(resources: dict) -> None:
+    """Set API resource instances in SDK state."""
+    global _sdk_state
+    _sdk_state.resources = resources
+
+
+def ensure_http_and_resources(api_key: Optional[str] = None, agent_id: Optional[str] = None) -> dict:
+    """Ensure HTTP client and resources are initialized, creating them if needed.
+    
+    This function checks if the HTTP client and resources already exist in SDK state.
+    If not, it creates them and stores them in SDK state for reuse.
+    
+    Args:
+        api_key: API key (uses env if not provided)
+        agent_id: Agent ID (uses env if not provided)
+        
+    Returns:
+        Dictionary of API resources with 'datasets' key
+        
+    Raises:
+        APIKeyVerificationError: If API key is not available
+    """
+    global _sdk_state
+    
+    # If we already have resources with datasets, return them
+    if _sdk_state.resources and 'datasets' in _sdk_state.resources:
+        return _sdk_state.resources
+    
+    # Need to create HTTP client and resources
+    from dotenv import load_dotenv
+    import os
+    from ..core.errors import APIKeyVerificationError
+    
+    load_dotenv()
+    
+    # Get credentials
+    if api_key is None:
+        api_key = os.getenv("LUCIDIC_API_KEY", None)
+        if api_key is None:
+            raise APIKeyVerificationError(
+                "Make sure to either pass your API key or set the LUCIDIC_API_KEY environment variable."
+            )
+    
+    if agent_id is None:
+        agent_id = os.getenv("LUCIDIC_AGENT_ID", None)
+    
+    # Create or reuse HTTP client
+    if not _sdk_state.http:
+        debug("[SDK] Creating HTTP client for standalone use")
+        config = SDKConfig.from_env(api_key=api_key, agent_id=agent_id)
+        _sdk_state.http = HttpClient(config)
+    
+    # Create resources if not already present
+    if not _sdk_state.resources:
+        _sdk_state.resources = {}
+    
+    if 'datasets' not in _sdk_state.resources:
+        debug("[SDK] Creating DatasetResource for standalone use")
+        _sdk_state.resources['datasets'] = DatasetResource(_sdk_state.http)
+    
+    return _sdk_state.resources
+
+
 def get_tracer_provider() -> Optional[TracerProvider]:
     """Get the tracer provider instance."""
     return _sdk_state.tracer_provider

{lucidicai-2.1.2 → lucidicai-2.1.3}/lucidicai/utils/images.py

@@ -11,7 +11,7 @@ import logging
 import threading
 from typing import List, Dict, Any, Optional, Tuple, Union
 from PIL import Image
-import requests
+import httpx
 
 logger = logging.getLogger("Lucidic")
 
@@ -299,9 +299,9 @@ class ImageUploader:
             image_obj, content_type = ImageHandler.prepare_for_upload(image_data, format)
         
         # Upload to S3
-        upload_response = requests.put(
+        upload_response = httpx.put(
             url,
-            data=image_obj.getvalue() if hasattr(image_obj, 'getvalue') else image_obj,
+            content=image_obj.getvalue() if hasattr(image_obj, 'getvalue') else image_obj,
             headers={"Content-Type": content_type}
         )
         upload_response.raise_for_status()

{lucidicai-2.1.2 → lucidicai-2.1.3}/lucidicai/utils/queue.py

@@ -9,7 +9,7 @@ import json
 import queue
 import threading
 import time
-import requests
+import httpx
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Set, Tuple
@@ -362,7 +362,7 @@ class EventQueue:
     def _upload_blob(self, blob_url: str, data: bytes) -> None:
         """Upload compressed blob to presigned URL."""
         headers = {"Content-Type": "application/json", "Content-Encoding": "gzip"}
-        resp = requests.put(blob_url, data=data, headers=headers)
+        resp = httpx.put(blob_url, content=data, headers=headers)
         resp.raise_for_status()
 
     @staticmethod

{lucidicai-2.1.2 → lucidicai-2.1.3}/lucidicai.egg-info/PKG-INFO

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

{lucidicai-2.1.2 → lucidicai-2.1.3}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="lucidicai",
-    version="2.1.2",
+    version="2.1.3",
     packages=find_packages(),
     install_requires=[
         "requests>=2.25.1",

lucidicai-2.1.2/lucidicai/api/client.py

@@ -1,218 +0,0 @@
-"""Pure HTTP client for Lucidic API communication.
-
-This module contains only the HTTP client logic, separated from
-session management and other concerns.
-"""
-import json
-from typing import Any, Dict, Optional
-from urllib.parse import urlencode
-
-import requests
-from requests.adapters import HTTPAdapter
-from urllib3.util import Retry
-
-from ..core.config import SDKConfig, get_config
-from ..core.errors import APIKeyVerificationError
-from ..utils.logger import debug, info, warning, error, mask_sensitive, truncate_data
-
-
-class HttpClient:
-    """HTTP client for API communication."""
-    
-    def __init__(self, config: Optional[SDKConfig] = None):
-        """Initialize the HTTP client.
-        
-        Args:
-            config: SDK configuration (uses global if not provided)
-        """
-        self.config = config or get_config()
-        self.base_url = self.config.network.base_url
-        
-        # Create session with connection pooling
-        self.session = requests.Session()
-        
-        # Configure retries
-        retry_cfg = Retry(
-            total=self.config.network.max_retries,
-            backoff_factor=self.config.network.backoff_factor,
-            status_forcelist=[502, 503, 504],
-            allowed_methods=["GET", "POST", "PUT", "DELETE"],
-        )
-        
-        # Configure adapter with connection pooling
-        adapter = HTTPAdapter(
-            max_retries=retry_cfg,
-            pool_connections=self.config.network.connection_pool_size,
-            pool_maxsize=self.config.network.connection_pool_maxsize
-        )
-        
-        self.session.mount("https://", adapter)
-        self.session.mount("http://", adapter)
-        
-        # Set headers
-        self._update_headers()
-        
-        # Verify API key if configured
-        if self.config.api_key:
-            self._verify_api_key()
-    
-    def _update_headers(self) -> None:
-        """Update session headers with authentication."""
-        headers = {
-            "User-Agent": "lucidic-sdk/2.0",
-            "Content-Type": "application/json"
-        }
-        
-        if self.config.api_key:
-            headers["Authorization"] = f"Api-Key {self.config.api_key}"
-        
-        if self.config.agent_id:
-            headers["x-agent-id"] = self.config.agent_id
-        
-        self.session.headers.update(headers)
-    
-    def _verify_api_key(self) -> None:
-        """Verify the API key with the backend."""
-        debug("[HTTP] Verifying API key")
-        try:
-            response = self.get("verifyapikey")
-            # Backend returns 200 OK for valid key, check if we got a response
-            if response is None:
-                raise APIKeyVerificationError("No response from API")
-            info("[HTTP] API key verified successfully")
-        except APIKeyVerificationError:
-            raise
-        except requests.RequestException as e:
-            raise APIKeyVerificationError(f"Could not verify API key: {e}")
-    
-    def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Make a GET request.
-        
-        Args:
-            endpoint: API endpoint (without base URL)
-            params: Query parameters
-            
-        Returns:
-            Response data as dictionary
-        """
-        return self.request("GET", endpoint, params=params)
-    
-    def post(self, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Make a POST request.
-        
-        Args:
-            endpoint: API endpoint (without base URL)
-            data: Request body data
-            
-        Returns:
-            Response data as dictionary
-        """
-        # Add current_time to all POST requests like TypeScript SDK does
-        from datetime import datetime, timezone
-        if data is None:
-            data = {}
-        data["current_time"] = datetime.now(timezone.utc).isoformat()
-        return self.request("POST", endpoint, json=data)
-    
-    def put(self, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Make a PUT request.
-        
-        Args:
-            endpoint: API endpoint (without base URL)
-            data: Request body data
-            
-        Returns:
-            Response data as dictionary
-        """
-        # Add current_time to all PUT requests like TypeScript SDK does
-        from datetime import datetime, timezone
-        if data is None:
-            data = {}
-        data["current_time"] = datetime.now(timezone.utc).isoformat()
-        return self.request("PUT", endpoint, json=data)
-    
-    def delete(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Make a DELETE request.
-        
-        Args:
-            endpoint: API endpoint (without base URL)
-            params: Query parameters
-            
-        Returns:
-            Response data as dictionary
-        """
-        return self.request("DELETE", endpoint, params=params)
-    
-    def request(
-        self,
-        method: str,
-        endpoint: str,
-        params: Optional[Dict[str, Any]] = None,
-        json: Optional[Dict[str, Any]] = None,
-        **kwargs
-    ) -> Dict[str, Any]:
-        """Make an HTTP request.
-        
-        Args:
-            method: HTTP method
-            endpoint: API endpoint (without base URL)
-            params: Query parameters
-            json: Request body (for POST/PUT)
-            **kwargs: Additional arguments for requests
-            
-        Returns:
-            Response data as dictionary
-            
-        Raises:
-            requests.RequestException: On HTTP errors
-        """
-        url = f"{self.base_url}/{endpoint}"
-        
-        # Log request details
-        debug(f"[HTTP] {method} {url}")
-        if params:
-            debug(f"[HTTP] Query params: {mask_sensitive(params)}")
-        if json:
-            debug(f"[HTTP] Request body: {truncate_data(mask_sensitive(json))}")
-        
-        response = self.session.request(
-            method=method,
-            url=url,
-            params=params,
-            json=json,
-            timeout=self.config.network.timeout,
-            **kwargs
-        )
-        
-        # Raise for HTTP errors with more detail
-        if not response.ok:
-            # Try to get error details from response
-            try:
-                error_data = response.json()
-                error_msg = error_data.get('detail', response.text)
-            except:
-                error_msg = response.text
-            
-            error(f"[HTTP] Error {response.status_code}: {error_msg}")
-        
-        response.raise_for_status()
-        
-        # Parse JSON response
-        try:
-            data = response.json()
-        except ValueError:
-            # For empty responses (like verifyapikey), return success
-            if response.status_code == 200 and not response.text:
-                data = {"success": True}
-            else:
-                # Return text if not JSON
-                data = {"response": response.text}
-        
-        debug(f"[HTTP] Response ({response.status_code}): {truncate_data(data)}")
-        
-        return data
-    
-    def close(self) -> None:
-        """Close the HTTP session."""
-        if self.session:
-            self.session.close()