lionagi 0.14.8__py3-none-any.whl → 0.14.10__py3-none-any.whl

lionagi/_errors.py

@@ -2,28 +2,137 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
+from typing import Any, ClassVar
+
+__all__ = (
+    "LionError",
+    "ValidationError",
+    "NotFoundError",
+    "ExistsError",
+    "ObservationError",
+    "ResourceError",
+    "RateLimitError",
+    "IDError",
+    "RelationError",
+    "OperationError",
+    "ExecutionError",
+    "ItemNotFoundError",
+    "ItemExistsError",
+)
+
 
 class LionError(Exception):
-    pass
+    default_message: ClassVar[str] = "LionAGI error"
+    default_status_code: ClassVar[int] = 500
+    __slots__ = ("message", "details", "status_code")
+
+    def __init__(
+        self,
+        message: str | None = None,
+        *,
+        details: dict[str, Any] | None = None,
+        status_code: int | None = None,
+        cause: Exception | None = None,
+    ):
+        super().__init__(message or self.default_message)
+        if cause:
+            self.__cause__ = cause  # preserves traceback
+        self.message = message or self.default_message
+        self.details = details or {}
+        self.status_code = status_code or type(self).default_status_code
+
+    def to_dict(self, *, include_cause: bool = False) -> dict[str, Any]:
+        data = {
+            "error": self.__class__.__name__,
+            "message": self.message,
+            "status_code": self.status_code,
+            **({"details": self.details} if self.details else {}),
+        }
+        if include_cause and (cause := self.get_cause()):
+            data["cause"] = repr(cause)
+        return data
+
+    def get_cause(self) -> Exception | None:
+        """Get the cause of this error, if any."""
+        return self.__cause__ if hasattr(self, "__cause__") else None
+
+    @classmethod
+    def from_value(
+        cls,
+        value: Any,
+        *,
+        expected: str | None = None,
+        message: str | None = None,
+        cause: Exception | None = None,
+        **extra: Any,
+    ):
+        """Create a ValidationError from a value with optional expected type and message."""
+        details = {
+            "value": value,
+            "type": type(value).__name__,
+            **({"expected": expected} if expected else {}),
+            **extra,
+        }
+        return cls(message=message, details=details, cause=cause)
 
 
-class ItemNotFoundError(LionError):
-    pass
+class ValidationError(LionError):
+    """Exception raised when validation fails."""
 
+    default_message = "Validation failed"
+    default_status_code = 422
+    __slots__ = ()
 
-class ItemExistsError(LionError):
-    pass
 
+class NotFoundError(LionError):
+    """Exception raised when an item is not found."""
 
-class IDError(LionError):
-    pass
+    default_message = "Item not found"
+    default_status_code = 404
+    __slots__ = ()
 
 
-class RelationError(LionError):
-    pass
+class ExistsError(LionError):
+    """Exception raised when an item already exists."""
+
+    default_message = "Item already exists"
+    default_status_code = 409
+    __slots__ = ()
+
+
+class ObservationError(LionError):
+    """Exception raised when an observation fails."""
+
+    default_message = "Observation failed"
+    default_status_code = 500
+    __slots__ = ()
+
+
+class ResourceError(LionError):
+    """Exception raised when resource access fails."""
+
+    default_message = "Resource error"
+    default_status_code = 429
+    __slots__ = ()
 
 
 class RateLimitError(LionError):
+    __slots__ = ("retry_after",)  # one extra attr
+    default_message = "Rate limit exceeded"
+    default_status_code = 429
+
+    def __init__(self, retry_after: float, **kw):
+        super().__init__(**kw)
+        object.__setattr__(self, "retry_after", retry_after)
+
+
+class IDError(LionError):
+    pass
+
+
+class RelationError(LionError):
     pass
 
 
@@ -35,5 +144,5 @@ class ExecutionError(LionError):
     pass
 
 
-class ValidationError(LionError):
-    pass
+ItemNotFoundError = NotFoundError
+ItemExistsError = ExistsError

lionagi/_types.py

@@ -1,9 +1,3 @@
 from .fields import *
 from .models import *
-from .operations import (
-    BrainstormOperation,
-    ExpansionStrategy,
-    Operation,
-    PlanOperation,
-)
 from .protocols.types import *

lionagi/config.py

@@ -63,12 +63,14 @@ class AppSettings(BaseSettings, frozen=True):
     GROQ_API_KEY: SecretStr | None = None
     ANTHROPIC_API_KEY: SecretStr | None = None
 
+    OPENAI_DEFAULT_MODEL: str = "gpt-4.1-mini"
+
     # defaults models
     LIONAGI_EMBEDDING_PROVIDER: str = "openai"
     LIONAGI_EMBEDDING_MODEL: str = "text-embedding-3-small"
 
     LIONAGI_CHAT_PROVIDER: str = "openai"
-    LIONAGI_CHAT_MODEL: str = "gpt-4.1-nano"
+    LIONAGI_CHAT_MODEL: str = "gpt-4.1-mini"
 
     # default storage
     LIONAGI_AUTO_STORE_EVENT: bool = False

lionagi/fields/reason.py

@@ -4,8 +4,8 @@
 
 from pydantic import Field, field_validator
 
+from lionagi.libs.validate.to_num import to_num
 from lionagi.models import FieldModel, HashableModel
-from lionagi.utils import to_num
 
 __all__ = ("Reason",)
 

lionagi/libs/concurrency/throttle.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import asyncio
+import functools
+from time import sleep, time
+from typing import Any, Callable, TypeVar
+
+T = TypeVar("T")
+
+
+__all__ = ("Throttle",)
+
+
+class Throttle:
+    """
+    Provide a throttling mechanism for function calls.
+
+    When used as a decorator, it ensures that the decorated function can only
+    be called once per specified period. Subsequent calls within this period
+    are delayed to enforce this constraint.
+
+    Attributes:
+        period: The minimum time period (in seconds) between successive calls.
+    """
+
+    def __init__(self, period: float) -> None:
+        """
+        Initialize a new instance of Throttle.
+
+        Args:
+            period: The minimum time period (in seconds) between
+                successive calls.
+        """
+        self.period = period
+        self.last_called = 0
+
+    def __call__(self, func: Callable[..., T]) -> Callable[..., T]:
+        """
+        Decorate a synchronous function with the throttling mechanism.
+
+        Args:
+            func: The synchronous function to be throttled.
+
+        Returns:
+            The throttled synchronous function.
+        """
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            elapsed = time() - self.last_called
+            if elapsed < self.period:
+                sleep(self.period - elapsed)
+            self.last_called = time()
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    def __call_async__(
+        self, func: Callable[..., Callable[..., T]]
+    ) -> Callable[..., Callable[..., T]]:
+        """
+        Decorate an asynchronous function with the throttling mechanism.
+
+        Args:
+            func: The asynchronous function to be throttled.
+
+        Returns:
+            The throttled asynchronous function.
+        """
+
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs) -> Any:
+            elapsed = time() - self.last_called
+            if elapsed < self.period:
+                await asyncio.sleep(self.period - elapsed)
+            self.last_called = time()
+            return await func(*args, **kwargs)
+
+        return wrapper

lionagi/libs/parse.py

@@ -8,7 +8,8 @@ from lionagi.libs.schema.function_to_schema import function_to_schema
 from lionagi.libs.validate.fuzzy_match_keys import fuzzy_match_keys
 from lionagi.libs.validate.fuzzy_validate_mapping import fuzzy_validate_mapping
 from lionagi.libs.validate.string_similarity import string_similarity
-from lionagi.utils import fuzzy_parse_json, to_dict, to_json, to_num
+from lionagi.libs.validate.to_num import to_num
+from lionagi.utils import fuzzy_parse_json, to_dict, to_json
 
 validate_keys = fuzzy_match_keys  # for backward compatibility
 validate_mapping = fuzzy_validate_mapping  # for backward compatibility

lionagi/libs/unstructured/pdf_to_image.py

@@ -0,0 +1,45 @@
+from lionagi.utils import check_import, is_import_installed
+
+_HAS_PDF2IMAGE = is_import_installed("pdf2image")
+
+
+def pdf_to_images(
+    pdf_path: str, output_folder: str, dpi: int = 300, fmt: str = "jpeg"
+) -> list:
+    """
+    Convert a PDF file into images, one image per page.
+
+    Args:
+        pdf_path (str): Path to the input PDF file.
+        output_folder (str): Directory to save the output images.
+        dpi (int): Dots per inch (resolution) for conversion (default: 300).
+        fmt (str): Image format (default: 'jpeg'). Use 'png' if preferred.
+
+    Returns:
+        list: A list of file paths for the saved images.
+    """
+    if not _HAS_PDF2IMAGE:
+        raise ModuleNotFoundError(
+            "pdf2image is not installed, please install it with `pip install lionagi[unstructured]`"
+        )
+
+    import os
+
+    convert_from_path = check_import(
+        "pdf2image", import_name="convert_from_path"
+    )
+
+    # Ensure the output folder exists
+    os.makedirs(output_folder, exist_ok=True)
+
+    # Convert PDF to a list of PIL Image objects
+    images = convert_from_path(pdf_path, dpi=dpi)
+
+    saved_paths = []
+    for i, image in enumerate(images):
+        # Construct the output file name
+        image_file = os.path.join(output_folder, f"page_{i + 1}.{fmt}")
+        image.save(image_file, fmt.upper())
+        saved_paths.append(image_file)
+
+    return saved_paths

lionagi/libs/unstructured/read_image_to_base64.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+
+from lionagi.utils import is_import_installed
+
+_HAS_OPENCV = is_import_installed("cv2")
+
+
+__all__ = ("read_image_to_base64",)
+
+
+def read_image_to_base64(image_path: str | Path) -> str:
+    if not _HAS_OPENCV:
+        raise ModuleNotFoundError(
+            "OpenCV is not installed, please install it with `pip install lionagi[unstructured]`"
+        )
+
+    import base64
+
+    import cv2
+
+    image_path = str(image_path)
+    image = cv2.imread(image_path, cv2.COLOR_BGR2RGB)
+
+    if image is None:
+        raise ValueError(f"Could not read image from path: {image_path}")
+
+    file_extension = "." + image_path.split(".")[-1]
+
+    success, buffer = cv2.imencode(file_extension, image)
+    if not success:
+        raise ValueError(f"Could not encode image to {file_extension} format.")
+    encoded_image = base64.b64encode(buffer).decode("utf-8")
+    return encoded_image