airia 0.1.2__py3-none-any.whl

airia/__init__.py

@@ -0,0 +1,6 @@
+from .logs import configure_logging
+from .client import AiriaClient, AiriaAsyncClient
+from .exceptions import AiriaAPIError
+
+__version__ = "0.1.0"
+__all__ = ["AiriaClient", "AiriaAsyncClient", "AiriaAPIError", "configure_logging"]

airia/exceptions.py

@@ -0,0 +1,33 @@
+class AiriaAPIError(Exception):
+    '''
+    Custom exception for Airia API errors.
+    
+    This exception is raised when an API request to the Airia service fails.
+    It contains both the HTTP status code and error message to help with
+    debugging and proper error handling.
+    
+    Attributes:
+        status_code (int): The HTTP status code returned by the API
+        message (str): The error message describing what went wrong
+    '''
+    
+    def __init__(self, status_code: int, message: str):
+        """
+        Initialize the exception with a status code and error message.
+        
+        Args:
+            status_code (int): The HTTP status code of the failed request
+            message (str): A descriptive error message
+        """
+        super().__init__(f"{status_code}: {message}")
+        self.status_code = status_code
+        self.message = message
+    
+    def __str__(self) -> str:
+        """
+        Return a string representation of the exception.
+        
+        Returns:
+            str: A formatted string containing the status code and message
+        """
+        return f"{self.status_code}: {self.message}"

airia/logs.py

@@ -0,0 +1,159 @@
+import os
+import sys
+import uuid
+from contextvars import ContextVar
+from typing import BinaryIO, Optional, TextIO, Union, overload
+
+import loguru
+from loguru import logger
+
+# Create a context variable to store correlation ID
+correlation_id_context: ContextVar[str] = ContextVar('correlation_id', default='')
+
+
+def get_correlation_id() -> str:
+    """
+    Get the current correlation ID from context or return empty string if not set.
+    
+    Returns:
+        str: The current correlation ID
+    """
+    return correlation_id_context.get()
+
+
+def set_correlation_id(correlation_id: Optional[str] = None) -> str:
+    """
+    Set a correlation ID in the current context.
+    
+    Args:
+        correlation_id (Optional[str]): The correlation ID to set. If None, a new UUID will be generated.
+        
+    Returns:
+        str: The correlation ID that was set
+    """
+    if correlation_id is None:
+        correlation_id = str(uuid.uuid4())
+    correlation_id_context.set(correlation_id)
+    return correlation_id
+
+
+def clear_correlation_id() -> None:
+    """Clear the correlation ID from the current context."""
+    correlation_id_context.set('')
+
+
+# Define a function to be used as a filter to inject correlation_id
+def correlation_id_filter(record):
+    record["extra"]["correlation_id"] = get_correlation_id() or "no-correlation-id"
+    return record
+
+
+@overload
+def configure_logging(
+    format_string: str = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+    level: str = "INFO",
+    sink: Union[TextIO, BinaryIO] = ...,
+    rotation: None = None,
+    retention: None = None,
+    include_correlation_id: bool = True,
+) -> "loguru.Logger": ...
+
+
+@overload
+def configure_logging(
+    format_string: str = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+    level: str = "INFO",
+    sink: Union[str, os.PathLike[str]] = ...,
+    rotation: Optional[str] = None,
+    retention: Optional[str] = None,
+    include_correlation_id: bool = True,
+) -> "loguru.Logger": ...
+
+
+def configure_logging(
+    format_string: str = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+    level: str = "INFO",
+    sink: Union[os.PathLike[str], TextIO, BinaryIO] = sys.stderr,
+    rotation: Optional[str] = None,
+    retention: Optional[str] = None,
+    include_correlation_id: bool = True,
+) -> "loguru.Logger":
+    """
+    Configure the loguru logger with custom settings.
+    Check [Loguru Documentation](https://loguru.readthedocs.io/en/stable/api/logger.html) for more details.
+
+    Args:
+        format_string (str): The format string for log messages.
+        level (str): The minimum logging level. Default: "INFO"
+        sink: Where to send the log. Default: sys.stderr
+        rotation (str, optional): When to rotate the log file.
+                                  Example: "10 MB", "1 day"
+                                  Only used when sink is a file path.
+        retention (str, optional): How long to keep log files.
+                                   Example: "1 week", "10 days"
+                                   Only used when sink is a file path.
+        include_correlation_id (bool): Whether to include correlation ID in log messages.
+                                      Default: True
+
+    Returns:
+        The configured logger object
+    """
+    # Remove any existing handlers
+    logger.remove()
+
+    # Modify format string to include correlation ID if requested
+    if include_correlation_id:
+        format_string = "<magenta>[{extra[correlation_id]}]</magenta> " + format_string
+
+    # Add rotation and retention only for file paths
+    kwargs = {
+        "format": format_string,
+        "level": level,
+        "filter": correlation_id_filter,  # Add the filter for each handler
+    }
+
+    if isinstance(sink, (str, os.PathLike)):
+        if rotation is not None:
+            kwargs["rotation"] = rotation
+        if retention is not None:
+            kwargs["retention"] = retention
+
+    # Add the new handler
+    logger.add(sink, **kwargs)
+    
+    return logger
+
+
+# Example usage:
+if __name__ == "__main__":
+    # Basic configuration (uses sys.stderr)
+    log = configure_logging()
+    log.info("Basic logging configured successfully")
+    
+    # Set a correlation ID
+    set_correlation_id("request-123")
+    log.info("This log has a correlation ID")
+    
+    # Change correlation ID
+    set_correlation_id("request-456")
+    log.info("This log has a different correlation ID")
+    
+    # Use auto-generated correlation ID
+    set_correlation_id()
+    log.info("This log has an auto-generated correlation ID")
+
+    # File-based logging with rotation and retention
+    file_log = configure_logging(
+        format_string="[{time:YYYY-MM-DD HH:mm:ss}] [{level}] {message}",
+        level="DEBUG",
+        sink="app.log",
+        rotation="10 MB",
+        retention="1 week",
+    )
+    file_log.debug("File logging configured successfully")
+
+    # Stream-based logging
+    stream_log = configure_logging(
+        format_string="[{time:HH:mm:ss}] {message}", level="INFO", sink=sys.stdout
+    )
+    stream_log.info("Stream logging configured successfully")

airia-0.1.2.dist-info/METADATA

@@ -0,0 +1,422 @@
+Metadata-Version: 2.4
+Name: airia
+Version: 0.1.2
+Summary: Python SDK for Airia API
+Author-email: Airia LLC <support@airia.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.32.3
+Requires-Dist: aiohttp>=3.11.14
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: pydantic>=2.11.0
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.49.0; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.74.0; extra == "openai"
+Provides-Extra: all
+Requires-Dist: anthropic>=0.49.0; extra == "all"
+Requires-Dist: openai>=1.74.0; extra == "all"
+Dynamic: license-file
+
+# Airia Python API Library
+
+Airia Python API Library that provides a clean and intuitive interface to interact with the Airia AI platform API. The library offers both synchronous and asynchronous clients for maximum flexibility in your applications.
+
+## Features
+
+- **Dual Client Support**: Choose between synchronous (`AiriaClient`) and asynchronous (`AiriaAsyncClient`) implementations
+- **Pipeline Execution**: Easily run AI pipelines with customizable parameters
+- **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
+
+## Installation
+
+Clone the repository:
+
+```bash
+git clone https://github.com/AiriaLLC/airia-python.git
+cd airia-python
+```
+
+You can install the package using pip or uv:
+
+<table>
+<tr>
+<th>pip</th>
+<th>uv</th>
+</tr>
+<tr>
+<td>
+
+```bash
+pip install -e .
+```
+
+</td>
+<td>
+
+```bash
+uv sync --frozen
+```
+
+</td>
+</tr>
+</table>
+
+### Install with optional dependencies
+
+The package supports optional dependencies for gateway functionality:
+
+<table>
+<tr>
+<th>OpenAI Gateway</th>
+<th>Anthropic Gateway</th>
+<th>All Gateways</th>
+</tr>
+<tr>
+<td>
+
+```bash
+pip install -e .[openai]
+```
+
+</td>
+<td>
+
+```bash
+pip install -e .[anthropic]
+```
+
+</td>
+<td>
+
+```bash
+pip install -e .[all]
+```
+
+</td>
+</tr>
+</table>
+
+### Install with development dependencies
+
+<table>
+<tr>
+<th>pip</th>
+<th>uv</th>
+</tr>
+<tr>
+<td>
+
+```bash
+pip install dependency-groups
+dev=$(python -m dependency_groups dev)
+pip install -e .
+pip install $dev
+```
+
+</td>
+<td>
+
+```bash
+uv sync --frozen --group dev
+```
+
+</td>
+</tr>
+</table>
+
+## Building from Source
+
+To build the package from source:
+
+<table>
+<tr>
+<th>pip</th>
+<th>uv</th>
+</tr>
+<tr>
+<td>
+
+```bash
+pip install build
+python -m build
+```
+
+</td>
+<td>
+
+```bash
+uv build
+```
+
+</td>
+</tr>
+</table>
+
+This will create both wheel and source distribution in the `dist/` directory.
+
+## Quick Start
+
+### Synchronous Usage
+
+```python
+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")
+
+# 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
+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")
+
+# Execute a pipeline
+response = client.execute_pipeline(
+    pipeline_id="your_pipeline_id",
+    user_input="Tell me about quantum computing",
+    async_output=True
+)
+
+for c in resp.stream:
+    print(c, end="")
+```
+
+### Asynchronous Usage
+
+```python
+import asyncio
+from airia import AiriaAsyncClient
+
+async def main():
+    # Use async context manager for proper session handling
+    async with AiriaAsyncClient(api_key="your_api_key") as client:
+        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
+import asyncio
+from airia import AiriaAsyncClient
+
+async def main():
+    # Use async context manager for proper session handling
+    async with AiriaAsyncClient(api_key="your_api_key") as client:
+        response = await client.execute_pipeline(
+            pipeline_id="your_pipeline_id",
+            user_input="Tell me about quantum computing",
+            async_output=True
+        )
+        async for c in resp.stream:
+            print(c, end="")
+
+asyncio.run(main())
+```
+
+## 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.
+
+### OpenAI Gateway
+
+```python
+from airia import AiriaClient
+
+# Initialize client with OpenAI gateway support
+client = AiriaClient.with_openai_gateway(api_key="your_airia_api_key")
+
+# Use OpenAI's API through Airia's gateway
+response = client.openai.chat.completions.create(
+    model="gpt-4.1-nano",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Hello!"},
+    ]
+)
+
+print(response.choices[0].message.content)
+```
+
+### Anthropic Gateway
+
+```python
+from airia import AiriaClient
+
+# Initialize client with Anthropic gateway support
+client = AiriaClient.with_anthropic_gateway(api_key="your_airia_api_key")
+
+# Use Anthropic's API through Airia's gateway
+response = client.anthropic.messages.create(
+    model="claude-3-5-haiku-20241022",
+    max_tokens=1000,
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+
+print(response.content[0].text)
+```
+
+### Asynchronous Gateway Usage
+
+Both gateways also support asynchronous usage:
+
+```python
+import asyncio
+from airia import AiriaAsyncClient
+
+async def main():
+    # Initialize async client with gateway support
+    client = AiriaAsyncClient.with_openai_gateway(api_key="your_airia_api_key")
+    
+    # Use OpenAI's API asynchronously through Airia's gateway
+    response = await client.openai.chat.completions.create(
+        model="gpt-4.1-nano",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Hello!"},
+        ]
+    )
+    
+    print(response.choices[0].message.content)
+
+asyncio.run(main())
+```
+
+## Advanced Usage
+
+### Pipeline Execution with All Options
+
+```python
+response = client.execute_pipeline(
+    pipeline_id="pipeline_id",
+    user_input="Your input text",
+    debug=True,                          # Enable debug mode
+    user_id="user_guid",                 # User identifier 
+    conversation_id="conversation_guid", # Conversation identifier
+    async_output=False,                  # Stream response (async mode)
+    include_tools_response=True,         # Return the initial LLM tool result
+    images=["base64_encoded_image"],     # Include image data
+    files=["base64_encoded_file"],       # Include file data
+    data_source_folders={},              # Data source folders configuration
+    data_source_files={},                # Data source files configuration
+    in_memory_messages=[                 # Context messages for conversation
+        {"role": "user", "message": "Previous message"}
+    ],
+    current_date_time="2025-03-26T21:00:00", # Override current date/time
+    save_history=True,                   # Save to conversation history
+    additional_info=["extra data"],      # Additional metadata
+    prompt_variables={"var1": "value1"}, # Variables for prompt templating
+    correlation_id="request-123",        # Request tracing ID
+    api_version="v2"                     # API version for the request
+)
+```
+
+### Configuring Logging
+
+```python
+import sys
+from airia import configure_logging
+
+# Basic configuration
+logger = configure_logging()
+
+# Advanced configuration
+file_logger = configure_logging(
+    format_string="[{time:YYYY-MM-DD HH:mm:ss}] [{level}] {message}",
+    level="DEBUG",
+    sink="app.log",
+    rotation="10 MB",
+    retention="1 week",
+    include_correlation_id=True
+)
+
+# Console output with custom format
+console_logger = configure_logging(
+    format_string="[{time:HH:mm:ss}] {message}",
+    level="INFO",
+    sink=sys.stdout
+)
+```
+
+## Error Handling
+
+The SDK uses custom exceptions to provide clear error messages:
+
+```python
+from airia import AiriaAPIError
+
+try:
+    response = client.execute_pipeline(
+        pipeline_id="invalid_id",
+        user_input="test"
+    )
+except AiriaAPIError as e:
+    print(f"API error: {e.status_code} - {e.message}")
+```
+
+## Requirements
+
+- Python 3.9 or higher
+- Core dependencies:
+  - requests
+  - aiohttp
+  - loguru
+  - pydantic
+
+- Optional dependencies:
+  - OpenAI gateway: `openai>=1.74.0`
+  - Anthropic gateway: `anthropic>=0.49.0`
+
+## Development
+
+To run tests (make sure you have development dependencies installed):
+
+```bash
+pytest
+```
+
+For testing gateway functionality, install the optional dependencies:
+
+```bash
+# For OpenAI gateway tests
+pip install -e .[openai]
+pytest tests/test_openai_gateway.py
+
+# For Anthropic gateway tests
+pip install -e .[anthropic]
+pytest tests/test_anthropic_gateway.py
+
+# For all tests
+pip install -e .[all]
+pytest
+```

airia-0.1.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+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-0.1.2.dist-info/licenses/LICENSE,sha256=R3ClUMMKPRItIcZ0svzyj2taZZnFYw568YDNzN9KQ1Q,1066
+airia-0.1.2.dist-info/METADATA,sha256=P6kEfX-udLEj3GNG1qvZcq4SEPOS_rFB_DNuuX2X3QQ,9578
+airia-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+airia-0.1.2.dist-info/top_level.txt,sha256=qUQEKfs_hdOYTwjKj1JZbRhS5YeXDNaKQaVTrzabS6w,6
+airia-0.1.2.dist-info/RECORD,,

airia-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

airia-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Airia LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

airia-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+airia