airia 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

airia/client/async_client.py

@@ -6,6 +6,7 @@ from urllib.parse import urljoin
 import aiohttp
 import loguru
 
+from ..constants import DEFAULT_ANTHROPIC_GATEWAY_URL, DEFAULT_BASE_URL, DEFAULT_OPENAI_GATEWAY_URL, DEFAULT_TIMEOUT
 from ..exceptions import AiriaAPIError
 from ..types import (
     ApiVersion,
@@ -14,6 +15,7 @@ from ..types import (
     PipelineExecutionResponse,
     PipelineExecutionV1StreamedResponse,
     PipelineExecutionV2AsyncStreamedResponse,
+    ProjectItem,
     RequestData,
 )
 from ..utils.sse_parser import async_parse_sse_stream_chunked
@@ -25,9 +27,10 @@ class AiriaAsyncClient(AiriaBaseClient):
 
     def __init__(
         self,
-        base_url: str = "https://api.airia.ai/",
+        base_url: str = DEFAULT_BASE_URL,
         api_key: Optional[str] = None,
-        timeout: float = 30.0,
+        bearer_token: Optional[str] = None,
+        timeout: float = DEFAULT_TIMEOUT,
         log_requests: bool = False,
         custom_logger: Optional["loguru.Logger"] = None,
     ):
@@ -37,6 +40,7 @@ class AiriaAsyncClient(AiriaBaseClient):
         Args:
             base_url: Base URL of the Airia API.
             api_key: API key for authentication. If not provided, will attempt to use AIRIA_API_KEY environment variable.
+            bearer_token: Bearer token for authentication. Must be provided explicitly (no environment variable fallback).
             timeout: Request timeout in seconds.
             log_requests: Whether to log API requests and responses. Default is False.
             custom_logger: Optional custom logger object to use for logging. If not provided, will use a default logger when `log_requests` is True.
@@ -44,6 +48,7 @@ class AiriaAsyncClient(AiriaBaseClient):
         super().__init__(
             base_url=base_url,
             api_key=api_key,
+            bearer_token=bearer_token,
             timeout=timeout,
             log_requests=log_requests,
             custom_logger=custom_logger,
@@ -79,10 +84,10 @@ class AiriaAsyncClient(AiriaBaseClient):
     @classmethod
     def with_openai_gateway(
         cls,
-        base_url: str = "https://api.airia.ai/",
-        gateway_url: str = "https://gateway.airia.ai/openai/v1",
+        base_url: str = DEFAULT_BASE_URL,
+        gateway_url: str = DEFAULT_OPENAI_GATEWAY_URL,
         api_key: Optional[str] = None,
-        timeout: float = 30.0,
+        timeout: float = DEFAULT_TIMEOUT,
         log_requests: bool = False,
         custom_logger: Optional["loguru.Logger"] = None,
         **kwargs,
@@ -101,22 +106,22 @@ class AiriaAsyncClient(AiriaBaseClient):
         """
         from openai import AsyncOpenAI
 
-        api_key = cls._get_api_key(api_key)
+        client = cls(base_url=base_url, api_key=api_key, timeout=timeout, log_requests=log_requests, custom_logger=custom_logger)
         cls.openai = AsyncOpenAI(
-            api_key=api_key,
+            api_key=client.api_key,
             base_url=gateway_url,
             **kwargs,
         )
 
-        return cls(base_url, api_key, timeout, log_requests, custom_logger)
+        return client
 
     @classmethod
     def with_anthropic_gateway(
         cls,
-        base_url: str = "https://api.airia.ai/",
-        gateway_url: str = "https://gateway.airia.ai/anthropic",
+        base_url: str = DEFAULT_BASE_URL,
+        gateway_url: str = DEFAULT_ANTHROPIC_GATEWAY_URL,
         api_key: Optional[str] = None,
-        timeout: float = 30.0,
+        timeout: float = DEFAULT_TIMEOUT,
         log_requests: bool = False,
         custom_logger: Optional["loguru.Logger"] = None,
         **kwargs,
@@ -135,14 +140,41 @@ class AiriaAsyncClient(AiriaBaseClient):
         """
         from anthropic import AsyncAnthropic
 
-        api_key = cls._get_api_key(api_key)
+        client = cls(base_url=base_url, api_key=api_key, timeout=timeout, log_requests=log_requests, custom_logger=custom_logger)
         cls.anthropic = AsyncAnthropic(
-            api_key=api_key,
+            api_key=client.api_key,
             base_url=gateway_url,
             **kwargs,
         )
 
-        return cls(base_url, api_key, timeout, log_requests, custom_logger)
+        return client
+
+    @classmethod
+    def with_bearer_token(
+        cls,
+        bearer_token: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = DEFAULT_TIMEOUT,
+        log_requests: bool = False,
+        custom_logger: Optional["loguru.Logger"] = None,
+    ):
+        """
+        Initialize the asynchronous Airia API client with bearer token authentication.
+
+        Args:
+            bearer_token: Bearer token for authentication.
+            base_url: Base URL of the Airia API.
+            timeout: Request timeout in seconds.
+            log_requests: Whether to log API requests and responses. Default is False.
+            custom_logger: Optional custom logger object to use for logging. If not provided, will use a default logger when `log_requests` is True.
+        """
+        return cls(
+            base_url=base_url,
+            bearer_token=bearer_token,
+            timeout=timeout,
+            log_requests=log_requests,
+            custom_logger=custom_logger,
+        )
 
     def _handle_exception(
         self, e: aiohttp.ClientResponseError, url: str, correlation_id: str
@@ -158,12 +190,12 @@ class AiriaAsyncClient(AiriaBaseClient):
         # Extract error details from response
         error_message = e.message
 
-        # Make sure API key is not included in error messages
-        sanitized_message = (
-            error_message.replace(self.api_key, "[REDACTED]")
-            if self.api_key in error_message
-            else error_message
-        )
+        # Make sure sensitive auth information is not included in error messages
+        sanitized_message = error_message
+        if self.api_key and self.api_key in sanitized_message:
+            sanitized_message = sanitized_message.replace(self.api_key, "[REDACTED]")
+        if self.bearer_token and self.bearer_token in sanitized_message:
+            sanitized_message = sanitized_message.replace(self.bearer_token, "[REDACTED]")
 
         # Raise custom exception with status code and sanitized message
         raise AiriaAPIError(status_code=e.status, message=sanitized_message) from e
@@ -199,6 +231,7 @@ class AiriaAsyncClient(AiriaBaseClient):
                 method=method,
                 url=request_data.url,
                 json=request_data.payload,
+                params=request_data.params,
                 headers=request_data.headers,
                 timeout=self.timeout,
             ) as response:
@@ -250,6 +283,7 @@ class AiriaAsyncClient(AiriaBaseClient):
                 method=method,
                 url=request_data.url,
                 json=request_data.payload,
+                params=request_data.params,
                 headers=request_data.headers,
                 timeout=self.timeout,
                 chunked=True,
@@ -419,11 +453,11 @@ class AiriaAsyncClient(AiriaBaseClient):
             aiohttp.ClientError: For other request-related errors.
 
         Example:
-            >>> async with AiriaAsyncClient(api_key="your_api_key") as client:
-            ...     response = await client.execute_pipeline(
-            ...         pipeline_id="pipeline_123",
-            ...         user_input="Tell me about quantum computing"
-            ...     )
+            >>> client = AiriaAsyncClient(api_key="your_api_key")
+            ... response = await client.execute_pipeline(
+            ...     pipeline_id="pipeline_123",
+            ...     user_input="Tell me about quantum computing"
+            ... )
             >>> print(response.result)
         """
         request_data = self._pre_execute_pipeline(
@@ -462,9 +496,9 @@ class AiriaAsyncClient(AiriaBaseClient):
                 self.base_url, f"{api_version}/StreamSocketConfig/GenerateUrl"
             )
             request_data = self._prepare_request(
-                url,
-                {"socketIdentifier": resp},
-                request_data.headers["X-Correlation-ID"],
+                url=url,
+                payload={"socketIdentifier": resp},
+                correlation_id=request_data.headers["X-Correlation-ID"],
             )
             resp = await self._make_request("POST", request_data)
 
@@ -472,43 +506,126 @@ class AiriaAsyncClient(AiriaBaseClient):
 
         return PipelineExecutionV2AsyncStreamedResponse(stream=resp)
 
+    async def get_projects(
+        self,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ) -> List[ProjectItem]:
+        """
+        Retrieve a list of all projects accessible to the authenticated user.
+
+        This method fetches comprehensive information about all projects that the
+        current user has access to, including project metadata, creation details,
+        and status information.
+
+        Args:
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+            api_version (str, optional): The API version to use for the request.
+                Defaults to "v1". Valid versions are defined in ApiVersion enum.
+
+        Returns:
+            List[ProjectItem]: A list of ProjectItem objects containing project
+                information. Returns an empty list if no projects are accessible
+                or found.
+
+        Raises:
+            ValueError: If the provided api_version is not valid.
+            AiriaAPIError: If the API request fails, including cases where:
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaAsyncClient
+
+            client = AiriaAsyncClient(api_key="your_api_key")
+
+            # Get all accessible projects
+            projects = await client.get_projects()
+
+            for project in projects:
+                print(f"Project: {project.name}")
+                print(f"ID: {project.id}")
+                print(f"Description: {project.description}")
+                print(f"Created: {project.created_at}")
+                print("---")
+            ```
+
+        Note:
+            The returned projects are filtered based on the authenticated user's
+            permissions. Users will only see projects they have been granted
+            access to.
+        """
+        request_data = self._pre_get_projects(
+            correlation_id=correlation_id, api_version=api_version
+        )
+        resp = await self._make_request("GET", request_data)
+
+        if "items" not in resp or len(resp["items"]) == 0:
+            return []
+
+        return [ProjectItem(**item) for item in resp["items"]]
+
     async def get_active_pipelines_ids(
         self,
+        project_id: Optional[str] = None,
         correlation_id: Optional[str] = None,
         api_version: str = ApiVersion.V1.value,
     ) -> List[str]:
         """
         Retrieve a list of active pipeline IDs.
-        
-        This method fetches all currently active pipeline IDs from the Airia API.
-        These IDs can be used with other methods like execute_pipeline() or 
-        get_pipeline_config().
-        
+
+        This method fetches the IDs of all active pipelines, optionally filtered by project.
+        Active pipelines are those that are currently deployed and available for execution.
+
         Args:
-            api_version (str, optional): API version to use for the request. 
-                Must be one of the supported versions. Defaults to "v1".
-            correlation_id (str, optional): Unique identifier for request tracing
-                and logging. If not provided, a new UUID will be automatically 
-                generated.
-        
+            project_id (str, optional): The unique identifier of the project to filter
+                pipelines by. If not provided, returns active pipelines from all projects
+                accessible to the authenticated user.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+            api_version (str, optional): The API version to use for the request.
+                Defaults to "v1". Valid versions are defined in ApiVersion enum.
+
         Returns:
-            List[str]: A list of active pipeline ID strings. Returns an empty list
-                if no active pipelines are found.
-        
+            List[str]: A list of pipeline IDs that are currently active. Returns an
+                empty list if no active pipelines are found.
+
         Raises:
-            ValueError: If the provided API version is not supported.
-            AiriaAPIError: If the API request fails, including network errors,
-                authentication failures, or server errors.
-        
+            ValueError: If the provided api_version is not valid.
+            AiriaAPIError: If the API request fails, including cases where:
+                - The project_id doesn't exist (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
         Example:
-            >>> client = AiriaClient(api_key="your_api_key")
-            >>> pipeline_ids = client.get_active_pipelines_ids()
-            >>> print(f"Found {len(pipeline_ids)} active pipelines")
-            >>> for pipeline_id in pipeline_ids:
-            ...     print(f"Pipeline ID: {pipeline_id}")
+            ```python
+            from airia import AiriaAsyncClient
+
+            client = AiriaAsyncClient(api_key="your_api_key")
+
+            # Get all active pipeline IDs
+            pipeline_ids = await client.get_active_pipelines_ids()
+            print(f"Found {len(pipeline_ids)} active pipelines")
+
+            # Get active pipeline IDs for a specific project
+            project_pipelines = await client.get_active_pipelines_ids(
+                project_id="your_project_id"
+            )
+            print(f"Project has {len(project_pipelines)} active pipelines")
+            ```
+
+        Note:
+            Only pipelines with active versions are returned. Inactive or archived
+            pipelines are not included in the results.
         """
         request_data = self._pre_get_active_pipelines_ids(
-            correlation_id=correlation_id, api_version=api_version
+            project_id=project_id,
+            correlation_id=correlation_id,
+            api_version=api_version,
         )
         resp = await self._make_request("GET", request_data)
 
@@ -553,12 +670,12 @@ class AiriaAsyncClient(AiriaBaseClient):
 
         Example:
             ```python
-            from airia import AiriaClient
+            from airia import AiriaAsyncClient
 
-            client = AiriaClient(api_key="your_api_key")
+            client = AiriaAsyncClient(api_key="your_api_key")
 
             # Get pipeline configuration
-            config = client.get_pipeline_config(
+            config = await client.get_pipeline_config(
                 pipeline_id="your_pipeline_id"
             )
 

airia/client/base_client.py

@@ -5,6 +5,7 @@ from urllib.parse import urljoin
 
 import loguru
 
+from ..constants import DEFAULT_BASE_URL, DEFAULT_TIMEOUT
 from ..logs import configure_logging, set_correlation_id
 from ..types import ApiVersion, RequestData
 
@@ -17,9 +18,10 @@ class AiriaBaseClient:
 
     def __init__(
         self,
-        base_url: str = "https://api.airia.ai/",
+        base_url: str = DEFAULT_BASE_URL,
         api_key: Optional[str] = None,
-        timeout: float = 30.0,
+        bearer_token: Optional[str] = None,
+        timeout: float = DEFAULT_TIMEOUT,
         log_requests: bool = False,
         custom_logger: Optional["loguru.Logger"] = None,
     ):
@@ -28,12 +30,13 @@ class AiriaBaseClient:
 
         Args:
             api_key: API key for authentication. If not provided, will attempt to use AIRIA_API_KEY environment variable.
+            bearer_token: Bearer token for authentication. Must be provided explicitly (no environment variable fallback).
             timeout: Request timeout in seconds.
             log_requests: Whether to log API requests and responses. Default is False.
             custom_logger: Optional custom logger object to use for logging. If not provided, will use a default logger when `log_requests` is True.
         """
-        # Resolve API key: parameter takes precedence over environment variable
-        self.api_key = self.__class__._get_api_key(api_key)
+        # Resolve authentication credentials
+        self.api_key, self.bearer_token = self.__class__._resolve_auth_credentials(api_key, bearer_token)
 
         # Store configuration
         self.base_url = base_url
@@ -44,90 +47,91 @@ class AiriaBaseClient:
         self.logger = configure_logging() if custom_logger is None else custom_logger
 
     @staticmethod
-    def _get_api_key(api_key: Optional[str] = None):
+    def _resolve_auth_credentials(api_key: Optional[str] = None, bearer_token: Optional[str] = None):
         """
-        Get the API key from either the provided parameter or environment variable.
+        Resolve authentication credentials from parameters and environment variables.
 
         Args:
             api_key (Optional[str]): The API key provided as a parameter. Defaults to None.
+            bearer_token (Optional[str]): The bearer token provided as a parameter. Defaults to None.
 
         Returns:
-            str: The resolved API key.
+            tuple: (api_key, bearer_token) - exactly one will be non-None
 
         Raises:
-            ValueError: If no API key is provided through either method.
+            ValueError: If no authentication method is provided or if both are provided.
         """
-        api_key = api_key or os.environ.get("AIRIA_API_KEY")
-
-        if not api_key:
+        # Check for explicit conflict first
+        if api_key and bearer_token:
             raise ValueError(
-                "API key must be provided either as a parameter or through the AIRIA_API_KEY environment variable."
+                "Cannot provide both api_key and bearer_token. Please use only one authentication method."
             )
-
-        return api_key
+        
+        # If bearer token is explicitly provided, use it exclusively
+        if bearer_token:
+            return None, bearer_token
+        
+        # If API key is explicitly provided, use it exclusively
+        if api_key:
+            return api_key, None
+            
+        # If neither is provided explicitly, fall back to environment variable
+        resolved_api_key = os.environ.get("AIRIA_API_KEY")
+        if resolved_api_key:
+            return resolved_api_key, None
+        
+        # No authentication method found
+        raise ValueError(
+            "Authentication required. Provide either api_key (or set AIRIA_API_KEY environment variable) or bearer_token."
+        )
 
     def _prepare_request(
         self,
         url: str,
         payload: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
         correlation_id: Optional[str] = None,
     ):
-        """
-        Prepare the request parameters for an API call.
-
-        Args:
-            url (str): The endpoint URL for the API request.
-            payload (Optional[Dict[str, Any]]): The request payload/body to be sent.
-            correlation_id (Optional[str]): A unique identifier for tracing the request. If None, one will be generated.
-
-        Returns:
-            dict: A dictionary containing the prepared request parameters with the following keys:
-                - url: The request URL
-                - payload: The request payload
-                - headers: Request headers including API key and correlation ID
-                - correlation_id: The correlation ID used for the request
-
-        Note:
-            This method handles:
-            - Setting/generating correlation IDs
-            - Adding authentication headers
-            - Logging requests (if enabled) with sensitive information redacted
-        """
         # Set correlation ID if provided or generate a new one
         correlation_id = set_correlation_id(correlation_id)
 
-        # Add the X-API-KEY header and correlation ID
+        # Set up base headers
         headers = {
-            "X-API-KEY": self.api_key,
             "X-Correlation-ID": correlation_id,
             "Content-Type": "application/json",
         }
 
+        # Add authentication header based on the method used
+        if self.api_key:
+            headers["X-API-KEY"] = self.api_key
+        elif self.bearer_token:
+            headers["Authorization"] = f"Bearer {self.bearer_token}"
+
         # Log the request if enabled
         if self.log_requests:
-            # Create a sanitized copy of headers for logging
+            # Create a sanitized copy of headers and params for logging
             log_headers = headers.copy()
+            log_params = params.copy() if params is not None else {}
 
             # Filter out sensitive headers
             if "X-API-KEY" in log_headers:
                 log_headers["X-API-KEY"] = "[REDACTED]"
+            if "Authorization" in log_headers:
+                log_headers["Authorization"] = "[REDACTED]"
 
             # Process payload for logging
-            log_payload = None
-            if payload is not None:
-                log_payload = payload.copy()
-
-                if "images" in log_payload and log_payload["images"] is not None:
-                    log_payload["images"] = f"{len(log_payload['images'])} images"
-                if "files" in log_payload and log_payload["files"] is not None:
-                    log_payload["files"] = f"{len(log_payload['files'])} files"
-
-                log_payload = json.dumps(log_payload)
+            log_payload = payload.copy() if payload is not None else {}
+            if "images" in log_payload and log_payload["images"] is not None:
+                log_payload["images"] = f"{len(log_payload['images'])} images"
+            if "files" in log_payload and log_payload["files"] is not None:
+                log_payload["files"] = f"{len(log_payload['files'])} files"
+            log_payload = json.dumps(log_payload)
 
             self.logger.info(
                 f"API Request: POST {url}\n"
                 f"Headers: {json.dumps(log_headers)}\n"
                 f"Payload: {log_payload}"
+                f"Params: {json.dumps(log_params)}\n"
             )
 
         return RequestData(
@@ -135,6 +139,7 @@ class AiriaBaseClient:
                 "url": url,
                 "payload": payload,
                 "headers": headers,
+                "params": params,
                 "correlation_id": correlation_id,
             }
         )
@@ -184,12 +189,29 @@ class AiriaBaseClient:
             "promptVariables": prompt_variables,
         }
 
-        request_data = self._prepare_request(url, payload, correlation_id)
+        request_data = self._prepare_request(
+            url=url, payload=payload, correlation_id=correlation_id
+        )
+
+        return request_data
+
+    def _pre_get_projects(
+        self,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        if api_version not in ApiVersion.as_list():
+            raise ValueError(
+                f"Invalid API version: {api_version}. Valid versions are: {', '.join(ApiVersion.as_list())}"
+            )
+        url = urljoin(self.base_url, f"{api_version}/Project/paginated")
+        request_data = self._prepare_request(url, correlation_id=correlation_id)
 
         return request_data
 
     def _pre_get_active_pipelines_ids(
         self,
+        project_id: Optional[str] = None,
         correlation_id: Optional[str] = None,
         api_version: str = ApiVersion.V1.value,
     ):
@@ -198,7 +220,10 @@ class AiriaBaseClient:
                 f"Invalid API version: {api_version}. Valid versions are: {', '.join(ApiVersion.as_list())}"
             )
         url = urljoin(self.base_url, f"{api_version}/PipelinesConfig")
-        request_data = self._prepare_request(url, correlation_id=correlation_id)
+        params = {"projectId": project_id} if project_id is not None else None
+        request_data = self._prepare_request(
+            url, params=params, correlation_id=correlation_id
+        )
 
         return request_data
 
@@ -212,7 +237,23 @@ class AiriaBaseClient:
             raise ValueError(
                 f"Invalid API version: {api_version}. Valid versions are: {', '.join(ApiVersion.as_list())}"
             )
-        url = urljoin(self.base_url, f"{api_version}/PipelinesConfig/export/{pipeline_id}")
+        url = urljoin(
+            self.base_url, f"{api_version}/PipelinesConfig/export/{pipeline_id}"
+        )
+        request_data = self._prepare_request(url, correlation_id=correlation_id)
+
+        return request_data
+
+    def _pre_get_projects(
+        self,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        if api_version not in ApiVersion.as_list():
+            raise ValueError(
+                f"Invalid API version: {api_version}. Valid versions are: {', '.join(ApiVersion.as_list())}"
+            )
+        url = urljoin(self.base_url, f"{api_version}/Project/paginated")
         request_data = self._prepare_request(url, correlation_id=correlation_id)
 
         return request_data

airia/client/sync_client.py

@@ -4,6 +4,7 @@ from urllib.parse import urljoin
 import loguru
 import requests
 
+from ..constants import DEFAULT_ANTHROPIC_GATEWAY_URL, DEFAULT_BASE_URL, DEFAULT_OPENAI_GATEWAY_URL, DEFAULT_TIMEOUT
 from ..exceptions import AiriaAPIError
 from ..types import (
     ApiVersion,
@@ -12,6 +13,7 @@ from ..types import (
     PipelineExecutionResponse,
     PipelineExecutionV1StreamedResponse,
     PipelineExecutionV2StreamedResponse,
+    ProjectItem,
     RequestData,
 )
 from ..utils.sse_parser import parse_sse_stream_chunked
@@ -23,9 +25,10 @@ class AiriaClient(AiriaBaseClient):
 
     def __init__(
         self,
-        base_url: str = "https://api.airia.ai/",
+        base_url: str = DEFAULT_BASE_URL,
         api_key: Optional[str] = None,
-        timeout: float = 30.0,
+        bearer_token: Optional[str] = None,
+        timeout: float = DEFAULT_TIMEOUT,
         log_requests: bool = False,
         custom_logger: Optional["loguru.Logger"] = None,
     ):
@@ -35,6 +38,7 @@ class AiriaClient(AiriaBaseClient):
         Args:
             base_url: Base URL of the Airia API.
             api_key: API key for authentication. If not provided, will attempt to use AIRIA_API_KEY environment variable.
+            bearer_token: Bearer token for authentication. Must be provided explicitly (no environment variable fallback).
             timeout: Request timeout in seconds.
             log_requests: Whether to log API requests and responses. Default is False.
             custom_logger: Optional custom logger object to use for logging. If not provided, will use a default logger when `log_requests` is True.
@@ -42,6 +46,7 @@ class AiriaClient(AiriaBaseClient):
         super().__init__(
             base_url=base_url,
             api_key=api_key,
+            bearer_token=bearer_token,
             timeout=timeout,
             log_requests=log_requests,
             custom_logger=custom_logger,
@@ -54,10 +59,10 @@ class AiriaClient(AiriaBaseClient):
     @classmethod
     def with_openai_gateway(
         cls,
-        base_url: str = "https://api.airia.ai/",
-        gateway_url: str = "https://gateway.airia.ai/openai/v1",
+        base_url: str = DEFAULT_BASE_URL,
+        gateway_url: str = DEFAULT_OPENAI_GATEWAY_URL,
         api_key: Optional[str] = None,
-        timeout: float = 30.0,
+        timeout: float = DEFAULT_TIMEOUT,
         log_requests: bool = False,
         custom_logger: Optional["loguru.Logger"] = None,
         **kwargs,
@@ -76,22 +81,22 @@ class AiriaClient(AiriaBaseClient):
         """
         from openai import OpenAI
 
-        api_key = cls._get_api_key(api_key)
+        client = cls(base_url=base_url, api_key=api_key, timeout=timeout, log_requests=log_requests, custom_logger=custom_logger)
         cls.openai = OpenAI(
-            api_key=api_key,
+            api_key=client.api_key,
             base_url=gateway_url,
             **kwargs,
         )
 
-        return cls(base_url, api_key, timeout, log_requests, custom_logger)
+        return client
 
     @classmethod
     def with_anthropic_gateway(
         cls,
-        base_url: str = "https://api.airia.ai/",
-        gateway_url: str = "https://gateway.airia.ai/anthropic",
+        base_url: str = DEFAULT_BASE_URL,
+        gateway_url: str = DEFAULT_ANTHROPIC_GATEWAY_URL,
         api_key: Optional[str] = None,
-        timeout: float = 30.0,
+        timeout: float = DEFAULT_TIMEOUT,
         log_requests: bool = False,
         custom_logger: Optional["loguru.Logger"] = None,
         **kwargs,
@@ -110,14 +115,41 @@ class AiriaClient(AiriaBaseClient):
         """
         from anthropic import Anthropic
 
-        api_key = cls._get_api_key(api_key)
+        client = cls(base_url=base_url, api_key=api_key, timeout=timeout, log_requests=log_requests, custom_logger=custom_logger)
         cls.anthropic = Anthropic(
-            api_key=api_key,
+            api_key=client.api_key,
             base_url=gateway_url,
             **kwargs,
         )
 
-        return cls(base_url, api_key, timeout, log_requests, custom_logger)
+        return client
+
+    @classmethod
+    def with_bearer_token(
+        cls,
+        bearer_token: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = DEFAULT_TIMEOUT,
+        log_requests: bool = False,
+        custom_logger: Optional["loguru.Logger"] = None,
+    ):
+        """
+        Initialize the synchronous Airia API client with bearer token authentication.
+
+        Args:
+            bearer_token: Bearer token for authentication.
+            base_url: Base URL of the Airia API.
+            timeout: Request timeout in seconds.
+            log_requests: Whether to log API requests and responses. Default is False.
+            custom_logger: Optional custom logger object to use for logging. If not provided, will use a default logger when `log_requests` is True.
+        """
+        return cls(
+            base_url=base_url,
+            bearer_token=bearer_token,
+            timeout=timeout,
+            log_requests=log_requests,
+            custom_logger=custom_logger,
+        )
 
     def _handle_exception(self, e: requests.HTTPError, url: str, correlation_id: str):
         # Log the error response if enabled
@@ -140,12 +172,12 @@ class AiriaClient(AiriaBaseClient):
             # If JSON parsing fails or expected keys are missing
             error_message = f"API request failed: {str(e)}"
 
-        # Make sure API key is not included in error messages
-        sanitized_message = (
-            error_message.replace(self.api_key, "[REDACTED]")
-            if self.api_key in error_message
-            else error_message
-        )
+        # Make sure sensitive auth information is not included in error messages
+        sanitized_message = error_message
+        if self.api_key and self.api_key in sanitized_message:
+            sanitized_message = sanitized_message.replace(self.api_key, "[REDACTED]")
+        if self.bearer_token and self.bearer_token in sanitized_message:
+            sanitized_message = sanitized_message.replace(self.bearer_token, "[REDACTED]")
 
         # Raise custom exception with status code and sanitized message
         raise AiriaAPIError(
@@ -181,6 +213,7 @@ class AiriaClient(AiriaBaseClient):
                 method=method,
                 url=request_data.url,
                 json=request_data.payload,
+                params=request_data.params,
                 headers=request_data.headers,
                 timeout=self.timeout,
             )
@@ -231,6 +264,7 @@ class AiriaClient(AiriaBaseClient):
             response = self.session.request(
                 method=method,
                 url=request_data.url,
+                params=request_data.params,
                 json=request_data.payload,
                 headers=request_data.headers,
                 timeout=self.timeout,
@@ -445,8 +479,8 @@ class AiriaClient(AiriaBaseClient):
             )
             request_data = self._prepare_request(
                 url,
-                {"socketIdentifier": resp},
-                request_data.headers["X-Correlation-ID"],
+                payload={"socketIdentifier": resp},
+                correlation_id=request_data.headers["X-Correlation-ID"],
             )
             resp = self._make_request("POST", request_data)
 
@@ -454,43 +488,126 @@ class AiriaClient(AiriaBaseClient):
 
         return PipelineExecutionV2StreamedResponse(stream=resp)
 
+    def get_projects(
+        self,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ) -> List[ProjectItem]:
+        """
+        Retrieve a list of all projects accessible to the authenticated user.
+
+        This method fetches comprehensive information about all projects that the
+        current user has access to, including project metadata, creation details,
+        and status information.
+
+        Args:
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+            api_version (str, optional): The API version to use for the request.
+                Defaults to "v1". Valid versions are defined in ApiVersion enum.
+
+        Returns:
+            List[ProjectItem]: A list of ProjectItem objects containing project
+                information. Returns an empty list if no projects are accessible
+                or found.
+
+        Raises:
+            ValueError: If the provided api_version is not valid.
+            AiriaAPIError: If the API request fails, including cases where:
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaClient
+
+            client = AiriaClient(api_key="your_api_key")
+
+            # Get all accessible projects
+            projects = client.get_projects()
+
+            for project in projects:
+                print(f"Project: {project.name}")
+                print(f"ID: {project.id}")
+                print(f"Description: {project.description}")
+                print(f"Created: {project.created_at}")
+                print("---")
+            ```
+
+        Note:
+            The returned projects are filtered based on the authenticated user's
+            permissions. Users will only see projects they have been granted
+            access to.
+        """
+        request_data = self._pre_get_projects(
+            correlation_id=correlation_id, api_version=api_version
+        )
+        resp = self._make_request("GET", request_data)
+
+        if "items" not in resp or len(resp["items"]) == 0:
+            return []
+
+        return [ProjectItem(**item) for item in resp["items"]]
+
     def get_active_pipelines_ids(
         self,
+        project_id: Optional[str] = None,
         correlation_id: Optional[str] = None,
         api_version: str = ApiVersion.V1.value,
     ) -> List[str]:
         """
         Retrieve a list of active pipeline IDs.
 
-        This method fetches all currently active pipeline IDs from the Airia API.
-        These IDs can be used with other methods like execute_pipeline() or
-        get_pipeline_config().
+        This method fetches the IDs of all active pipelines, optionally filtered by project.
+        Active pipelines are those that are currently deployed and available for execution.
 
         Args:
-            api_version (str, optional): API version to use for the request.
-                Must be one of the supported versions. Defaults to "v1".
-            correlation_id (str, optional): Unique identifier for request tracing
-                and logging. If not provided, a new UUID will be automatically
-                generated.
+            project_id (str, optional): The unique identifier of the project to filter
+                pipelines by. If not provided, returns active pipelines from all projects
+                accessible to the authenticated user.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+            api_version (str, optional): The API version to use for the request.
+                Defaults to "v1". Valid versions are defined in ApiVersion enum.
 
         Returns:
-            List[str]: A list of active pipeline ID strings. Returns an empty list
-                if no active pipelines are found.
+            List[str]: A list of pipeline IDs that are currently active. Returns an
+                empty list if no active pipelines are found.
 
         Raises:
-            ValueError: If the provided API version is not supported.
-            AiriaAPIError: If the API request fails, including network errors,
-                authentication failures, or server errors.
+            ValueError: If the provided api_version is not valid.
+            AiriaAPIError: If the API request fails, including cases where:
+                - The project_id doesn't exist (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
 
         Example:
-            >>> client = AiriaClient(api_key="your_api_key")
-            >>> pipeline_ids = client.get_active_pipelines_ids()
-            >>> print(f"Found {len(pipeline_ids)} active pipelines")
-            >>> for pipeline_id in pipeline_ids:
-            ...     print(f"Pipeline ID: {pipeline_id}")
+            ```python
+            from airia import AiriaClient
+
+            client = AiriaClient(api_key="your_api_key")
+
+            # Get all active pipeline IDs
+            pipeline_ids = client.get_active_pipelines_ids()
+            print(f"Found {len(pipeline_ids)} active pipelines")
+
+            # Get active pipeline IDs for a specific project
+            project_pipelines = client.get_active_pipelines_ids(
+                project_id="your_project_id"
+            )
+            print(f"Project has {len(project_pipelines)} active pipelines")
+            ```
+
+        Note:
+            Only pipelines with active versions are returned. Inactive or archived
+            pipelines are not included in the results.
         """
         request_data = self._pre_get_active_pipelines_ids(
-            correlation_id=correlation_id, api_version=api_version
+            project_id=project_id,
+            correlation_id=correlation_id,
+            api_version=api_version,
         )
         resp = self._make_request("GET", request_data)
 

airia/constants.py

@@ -0,0 +1,9 @@
+"""Constants used throughout the Airia SDK."""
+
+# Default API endpoints
+DEFAULT_BASE_URL = "https://api.airia.ai/"
+DEFAULT_OPENAI_GATEWAY_URL = "https://gateway.airia.ai/openai/v1"
+DEFAULT_ANTHROPIC_GATEWAY_URL = "https://gateway.airia.ai/anthropic"
+
+# Default timeouts
+DEFAULT_TIMEOUT = 30.0

airia/types/__init__.py

@@ -1,3 +1,4 @@
+from .api.get_projects import ProjectItem
 from .api.get_pipeline_config import GetPipelineConfigResponse
 from .api.pipeline_execution import (
     PipelineExecutionDebugResponse,
@@ -43,6 +44,7 @@ __all__ = [
     "PipelineExecutionV2AsyncStreamedResponse",
     "PipelineExecutionV2StreamedResponse",
     "GetPipelineConfigResponse",
+    "ProjectItem",
     "RequestData",
     "AgentPingMessage",
     "AgentStartMessage",

airia/types/api/get_pipeline_config.py

@@ -101,7 +101,9 @@ class Model(BaseModel):
     url: str
     input_type: str = Field(alias="inputType")
     provider: str
-    credentials_definition: CredentialsDefinition = Field(alias="credentialsDefinition")
+    credentials_definition: Optional[CredentialsDefinition] = Field(
+        alias="credentialsDefinition"
+    )
     deployment_type: str = Field(alias="deploymentType")
     source_type: str = Field(alias="sourceType")
     connection_string: Optional[str] = Field(alias="connectionString", default=None)
@@ -135,10 +137,41 @@ class Router(BaseModel):
     router_config: Dict[str, Dict[str, Any]] = Field(alias="routerConfig")
 
 
+class ChunkingConfig(BaseModel):
+    id: str
+    chunk_size: int = Field(alias="chunkSize")
+    chunk_overlap: int = Field(alias="chunkOverlap")
+    strategy_type: str = Field(alias="strategyType")
+
+
+class DataSourceFile(BaseModel):
+    data_source_id: str = Field(alias="dataSourceId")
+    file_path: Optional[str] = Field(None, alias="filePath")
+    input_token: Optional[str] = Field(None, alias="inputToken")
+    file_count: Optional[int] = Field(None, alias="fileCount")
+
+
+class DataSource(BaseModel):
+    id: str = Field(alias="id")
+    name: Optional[str] = None
+    execution_name: Optional[str] = Field(None, alias="executionName")
+    chunking_config: ChunkingConfig = Field(alias="chunkingConfig")
+    data_source_type: str = Field(alias="dataSourceType")
+    database_type: str = Field(alias="databaseType")
+    embedding_provider: str = Field(alias="embeddingProvider")
+    is_user_specific: bool = Field(alias="isUserSpecific")
+    files: Optional[List[DataSourceFile]] = None
+    configuration_json: Optional[str] = Field(None, alias="configurationJson")
+    credentials: Optional[CredentialsDefinition]
+    is_image_processing_enabled: bool = Field(alias="isImageProcessingEnabled")
+
+
 class GetPipelineConfigResponse(BaseModel):
     metadata: Metadata
     agent: Agent
-    data_sources: Optional[List[Any]] = Field(alias="dataSources", default_factory=list)
+    data_sources: Optional[List[DataSource]] = Field(
+        alias="dataSources", default_factory=list
+    )
     prompts: Optional[List[Prompt]] = Field(default_factory=list)
     tools: Optional[List[Tool]] = Field(default_factory=list)
     models: Optional[List[Model]] = Field(default_factory=list)

airia/types/api/get_projects.py

@@ -0,0 +1,35 @@
+from datetime import datetime
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class Pipeline(BaseModel):
+    id: str
+    name: str
+
+
+class ProjectItem(BaseModel):
+    tenant_id: str = Field(alias="tenantId")
+    created_at: datetime = Field(alias="createdAt")
+    require_classification: bool = Field(alias="requireClassification")
+    budget_amount: Optional[Any] = Field(None, alias="budgetAmount")
+    budget_period: Optional[Any] = Field(None, alias="budgetPeriod")
+    budget_alert: Optional[Any] = Field(None, alias="budgetAlert")
+    budget_stop: bool = Field(alias="budgetStop")
+    used_budget_amount: Optional[Any] = Field(None, alias="usedBudgetAmount")
+    resume_ends_at: Optional[datetime] = Field(None, alias="resumeEndsAt")
+    updated_at: datetime = Field(alias="updatedAt")
+    pipelines: List[Pipeline]
+    models: Optional[Any] = None
+    data_sources: List[Any] = Field(alias="dataSources")
+    prompts: Optional[Any] = None
+    api_keys: Optional[Any] = Field(alias="apiKeys")
+    memories: Optional[Any] = None
+    project_icon: Optional[str] = Field(None, alias="projectIcon")
+    project_icon_id: Optional[str] = Field(None, alias="projectIconId")
+    description: Optional[str] = None
+    project_type: str = Field(alias="projectType")
+    classifications: Optional[Any] = None
+    id: str
+    name: str

airia/types/request_data.py

@@ -6,5 +6,6 @@ from pydantic import BaseModel
 class RequestData(BaseModel):
     url: str
     payload: Optional[Dict[str, Any]]
+    params: Optional[Dict[str, Any]]
     headers: Dict[str, Any]
     correlation_id: str

{airia-0.1.8.dist-info → airia-0.1.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airia
-Version: 0.1.8
+Version: 0.1.10
 Summary: Python SDK for Airia API
 Author-email: Airia LLC <support@airia.com>
 License: MIT
@@ -43,7 +43,9 @@ Airia Python API Library that provides a clean and intuitive interface to intera
 - **Gateway Support**: Seamlessly integrate with OpenAI and Anthropic services through Airia gateways
 - **Error Handling**: Comprehensive error handling with custom exceptions
 - **Logging**: Built-in configurable logging with correlation ID support for request tracing
-- **API Key Management**: Flexible API key configuration via parameters or environment variables
+- **Flexible Authentication**: Support for both API keys and bearer tokens with flexible configuration
+- **API Key Management**: API key configuration via parameters or environment variables
+- **Bearer Token Support**: Bearer token authentication for ephemeral, short-lived credentials
 
 ## Installation
 
@@ -181,17 +183,38 @@ This will create both wheel and source distribution in the `dist/` directory.
 ```python
 from airia import AiriaClient
 
+# API Key Authentication
 client = AiriaClient(
     base_url="https://api.airia.ai",        # Default: "https://api.airia.ai"
-    api_key=None,                  # Or set AIRIA_API_KEY environment variable
-    timeout=30.0,                            # Request timeout in seconds (default: 30.0)
-    log_requests=False,                       # Enable request/response logging (default: False)
-    custom_logger=None                       # Use custom logger (default: None - uses built-in)
+    api_key=None,                           # Or set AIRIA_API_KEY environment variable
+    timeout=30.0,                           # Request timeout in seconds (default: 30.0)
+    log_requests=False,                     # Enable request/response logging (default: False)
+    custom_logger=None                      # Use custom logger (default: None - uses built-in)
+)
+
+# Bearer Token Authentication
+client = AiriaClient(
+    base_url="https://api.airia.ai",        # Default: "https://api.airia.ai"
+    bearer_token="your_bearer_token",       # Must be provided explicitly (no env var fallback)
+    timeout=30.0,                           # Request timeout in seconds (default: 30.0)
+    log_requests=False,                     # Enable request/response logging (default: False)
+    custom_logger=None                      # Use custom logger (default: None - uses built-in)
+)
+
+# Convenience method for bearer token
+client = AiriaClient.with_bearer_token(
+    bearer_token="your_bearer_token",
+    base_url="https://api.airia.ai",        # Optional, uses default if not provided
+    timeout=30.0,                           # Optional, uses default if not provided
+    log_requests=False,                     # Optional, uses default if not provided
+    custom_logger=None                      # Optional, uses default if not provided
 )
 ```
 
 ### Synchronous Usage
 
+#### With API Key
+
 ```python
 from airia import AiriaClient
 
@@ -207,6 +230,23 @@ response = client.execute_pipeline(
 print(response.result)
 ```
 
+#### With Bearer Token
+
+```python
+from airia import AiriaClient
+
+# Initialize client with bearer token
+client = AiriaClient.with_bearer_token(bearer_token="your_bearer_token")
+
+# Execute a pipeline
+response = client.execute_pipeline(
+    pipeline_id="your_pipeline_id",
+    user_input="Tell me about quantum computing"
+)
+
+print(response.result)
+```
+
 #### Synchronous Streaming
 
 ```python
@@ -214,6 +254,7 @@ from airia import AiriaClient
 
 # Initialize client (API key can be passed directly or via AIRIA_API_KEY environment variable)
 client = AiriaClient(api_key="your_api_key")
+# Or with bearer token: client = AiriaClient.with_bearer_token(bearer_token="your_bearer_token")
 
 # Execute a pipeline
 response = client.execute_pipeline(
@@ -228,6 +269,8 @@ for c in response.stream:
 
 ### Asynchronous Usage
 
+#### With API Key
+
 ```python
 import asyncio
 from airia import AiriaAsyncClient
@@ -243,6 +286,23 @@ async def main():
 asyncio.run(main())
 ```
 
+#### With Bearer Token
+
+```python
+import asyncio
+from airia import AiriaAsyncClient
+
+async def main():
+    client = AiriaAsyncClient.with_bearer_token(bearer_token="your_bearer_token")
+    response = await client.execute_pipeline(
+        pipeline_id="your_pipeline_id",
+        user_input="Tell me about quantum computing"
+    )
+    print(response.result)
+
+asyncio.run(main())
+```
+
 #### Asynchronous Streaming
 
 ```python
@@ -251,6 +311,7 @@ from airia import AiriaAsyncClient
 
 async def main():
     client = AiriaAsyncClient(api_key="your_api_key")
+    # Or with bearer token: client = AiriaAsyncClient.with_bearer_token(bearer_token="your_bearer_token")
     response = await client.execute_pipeline(
         pipeline_id="your_pipeline_id",
         user_input="Tell me about quantum computing",
@@ -320,6 +381,7 @@ from airia import AiriaClient
 from airia.types import AgentModelStreamFragmentMessage
 
 client = AiriaClient(api_key="your_api_key")
+# Or with bearer token: client = AiriaClient.with_bearer_token(bearer_token="your_bearer_token")
 
 response = client.execute_pipeline(
     pipeline_id="your_pipeline_id",
@@ -343,6 +405,7 @@ You can retrieve detailed configuration information about a pipeline using the `
 from airia import AiriaClient
 
 client = AiriaClient(api_key="your_api_key")
+# Or with bearer token: client = AiriaClient.with_bearer_token(bearer_token="your_bearer_token")
 
 # Get pipeline configuration
 config = client.get_pipeline_config(pipeline_id="your_pipeline_id")
@@ -351,10 +414,35 @@ config = client.get_pipeline_config(pipeline_id="your_pipeline_id")
 print(f"Pipeline Name: {config.agent.name}")
 ```
 
+## Authentication Methods
+
+Airia supports two authentication methods:
+
+### API Keys
+- Can be passed as a parameter or via `AIRIA_API_KEY` environment variable
+- Support gateway functionality (OpenAI and Anthropic gateways)
+- Suitable for long-term, persistent authentication
+
+### Bearer Tokens
+- Must be provided explicitly (no environment variable fallback)
+- **Important**: Bearer tokens cannot be used with gateway functionality
+- Suitable for ephemeral, short-lived authentication scenarios
+- Ideal for temporary access or programmatic token generation
+
+```python
+# ✅ API key with gateway support
+client = AiriaClient.with_openai_gateway(api_key="your_api_key")
+
+# ❌ Bearer token with gateway - NOT SUPPORTED
+# client = AiriaClient.with_openai_gateway(bearer_token="token")  # This won't work
+```
+
 ## Gateway Usage
 
 Airia provides gateway capabilities for popular AI services like OpenAI and Anthropic, allowing you to use your Airia API key with these services.
 
+> **Note**: Gateway functionality requires API key authentication. Bearer tokens are not supported for gateway usage.
+
 ### OpenAI Gateway
 
 ```python
@@ -482,7 +570,11 @@ console_logger = configure_logging(
 The SDK uses custom exceptions to provide clear error messages:
 
 ```python
-from airia import AiriaAPIError
+from airia import AiriaAPIError, AiriaClient
+
+# Works with both API keys and bearer tokens
+client = AiriaClient(api_key="your_api_key")
+# Or: client = AiriaClient.with_bearer_token(bearer_token="your_bearer_token")
 
 try:
     response = client.execute_pipeline(

airia-0.1.10.dist-info/RECORD

@@ -0,0 +1,21 @@
+airia/__init__.py,sha256=T39gO8E5T5zxlw-JP78ruxOu7-LeKOJCJzz6t40kdQo,231
+airia/constants.py,sha256=fHZNUbvEP_x567uFI1qnA2DT8dOzQ07ojdawdPwIrIA,292
+airia/exceptions.py,sha256=4Z55n-cRJrtTa5-pZBIK2oZD4-Z99aUtKx_kfTFYY5o,1146
+airia/logs.py,sha256=17YZ4IuzOF0m5bgofj9-QYlJ2BYR2kRZbBVQfFSLFEk,5441
+airia/client/__init__.py,sha256=6gSQ9bl7j79q1HPE0o5py3IRdkwWWuU_7J4h05Dd2o8,127
+airia/client/async_client.py,sha256=9MJI4wVwFOcXVaeGN_JQjqnUO0zE12kbXJLTVP1rOe0,28599
+airia/client/base_client.py,sha256=04l7qQ-pvcq6bFOEMPh0x_6izJGTl0VnAxcFQgcFhOk,9859
+airia/client/sync_client.py,sha256=RdCOyzxPoEsj_x3JibmU4yPIqs07b_izyJ5PmbAj6Uw,27656
+airia/types/__init__.py,sha256=Tr1xm5bQrE7yvw0Bo-goNmeh7Rl0QiXUabg7dsJ55dk,2227
+airia/types/api_version.py,sha256=Uzom6O2ZG92HN_Z2h-lTydmO2XYX9RVs4Yi4DJmXytE,255
+airia/types/request_data.py,sha256=WUvf7fixhBPWLxKbc2VY3Y32BOUbLmXktY58mINuq3A,243
+airia/types/sse_messages.py,sha256=wSdowY07AjEO8R73SJrFPJtkfIBS4satUpNytjKQq2U,8305
+airia/types/api/get_pipeline_config.py,sha256=BLz4HS94EYmdwq37KHda2XJ5KV7tJPP43jHmPbO8-NE,6647
+airia/types/api/get_projects.py,sha256=kWmlN0VMgmQ9WP9ms245MAAEmsHhkpwWUQJ_XJrhIRI,1362
+airia/types/api/pipeline_execution.py,sha256=4zGM5W4aXiAibAdgWQCIZBC_blW6QYAlAHoVUMbnCF0,752
+airia/utils/sse_parser.py,sha256=h3TcBvXqUIngTqgY6yYxZCGLnC1eI6meQzYr13aFAb8,2791
+airia-0.1.10.dist-info/licenses/LICENSE,sha256=R3ClUMMKPRItIcZ0svzyj2taZZnFYw568YDNzN9KQ1Q,1066
+airia-0.1.10.dist-info/METADATA,sha256=xh195iJ9x3GO3kv2tqX2A9yj5lzjsvvi5dJGymn9L1U,16682
+airia-0.1.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+airia-0.1.10.dist-info/top_level.txt,sha256=qUQEKfs_hdOYTwjKj1JZbRhS5YeXDNaKQaVTrzabS6w,6
+airia-0.1.10.dist-info/RECORD,,

airia-0.1.8.dist-info/RECORD

@@ -1,19 +0,0 @@
-airia/__init__.py,sha256=T39gO8E5T5zxlw-JP78ruxOu7-LeKOJCJzz6t40kdQo,231
-airia/exceptions.py,sha256=4Z55n-cRJrtTa5-pZBIK2oZD4-Z99aUtKx_kfTFYY5o,1146
-airia/logs.py,sha256=17YZ4IuzOF0m5bgofj9-QYlJ2BYR2kRZbBVQfFSLFEk,5441
-airia/client/__init__.py,sha256=6gSQ9bl7j79q1HPE0o5py3IRdkwWWuU_7J4h05Dd2o8,127
-airia/client/async_client.py,sha256=QtnH1MNfF_ONx2YHsTz7Y4pFBTrggHWz0LLJiITREwc,23694
-airia/client/base_client.py,sha256=YWhQle7cmtiuc5BwiavW-NYjTC6kXyclpse4irwkMuI,7969
-airia/client/sync_client.py,sha256=iUqRn7Bv5hi-Qcg3Vgfc-Z1gx5T42f9Vq4pUTPsyG5M,22750
-airia/types/__init__.py,sha256=s6_uMrrKzhk2wg1lpaRRIl4AQ8hUxKbCNLfz-VK7tAs,2166
-airia/types/api_version.py,sha256=Uzom6O2ZG92HN_Z2h-lTydmO2XYX9RVs4Yi4DJmXytE,255
-airia/types/request_data.py,sha256=m8lBwFliK2_kZU2TgeLdhiO_7v826lVRhA5_8NYB_NM,206
-airia/types/sse_messages.py,sha256=wSdowY07AjEO8R73SJrFPJtkfIBS4satUpNytjKQq2U,8305
-airia/types/api/get_pipeline_config.py,sha256=HAKgcpiJKeG_TuWtxo28CeWiodhlsVBwgbpzDgd1Eoo,5401
-airia/types/api/pipeline_execution.py,sha256=4zGM5W4aXiAibAdgWQCIZBC_blW6QYAlAHoVUMbnCF0,752
-airia/utils/sse_parser.py,sha256=h3TcBvXqUIngTqgY6yYxZCGLnC1eI6meQzYr13aFAb8,2791
-airia-0.1.8.dist-info/licenses/LICENSE,sha256=R3ClUMMKPRItIcZ0svzyj2taZZnFYw568YDNzN9KQ1Q,1066
-airia-0.1.8.dist-info/METADATA,sha256=Toz3tWc8psnI2QbUrhjfzomljqp5BSrlaJH11mohHos,13218
-airia-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-airia-0.1.8.dist-info/top_level.txt,sha256=qUQEKfs_hdOYTwjKj1JZbRhS5YeXDNaKQaVTrzabS6w,6
-airia-0.1.8.dist-info/RECORD,,