lionagi 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

lionagi/core/models/field_model.py

@@ -2,9 +2,13 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from ..typing.pydantic_ import ConfigDict, Field, FieldInfo, field_validator
-from ..typing.typing_ import UNDEFINED, Any, Callable
-from .schema_model import SchemaModel, common_config
+from lionagi.libs.utils import is_same_dtype
+
+from ..typing._pydantic import ConfigDict, Field, FieldInfo, field_validator
+from ..typing._typing import UNDEFINED, Any, Callable, UndefinedType
+from .schema_model import SchemaModel
+
+__all__ = ("FieldModel",)
 
 
 class FieldModel(SchemaModel):
@@ -51,24 +55,34 @@ class FieldModel(SchemaModel):
     """
 
     model_config = ConfigDict(
-        extra="allow", validate_default=False, **common_config
+        extra="allow",
+        validate_default=False,
+        populate_by_name=True,
+        arbitrary_types_allowed=True,
+        use_enum_values=True,
     )
 
     # Field configuration attributes
     default: Any = UNDEFINED  # Default value
-    default_factory: Callable = UNDEFINED  # Factory function for default value
-    title: str = UNDEFINED  # Field title
-    description: str = UNDEFINED  # Field description
-    examples: list = UNDEFINED  # Example values
-    validators: list = UNDEFINED  # Validation functions
-    exclude: bool = UNDEFINED  # Exclude from serialization
-    deprecated: bool = UNDEFINED  # Mark as deprecated
-    frozen: bool = UNDEFINED  # Mark as immutable
-    alias: str = UNDEFINED  # Alternative field name
-    alias_priority: int = UNDEFINED  # Priority for alias resolution
+    default_factory: Callable | UndefinedType = (
+        UNDEFINED  # Factory function for default value
+    )
+    title: str | UndefinedType = UNDEFINED  # Field title
+    description: str | UndefinedType = UNDEFINED  # Field description
+    examples: list | UndefinedType = UNDEFINED  # Example values
+    validators: list | UndefinedType = UNDEFINED  # Validation functions
+    exclude: bool | UndefinedType = UNDEFINED  # Exclude from serialization
+    deprecated: bool | UndefinedType = UNDEFINED  # Mark as deprecated
+    frozen: bool | UndefinedType = UNDEFINED  # Mark as immutable
+    alias: str | UndefinedType = UNDEFINED  # Alternative field name
+    alias_priority: int | UndefinedType = (
+        UNDEFINED  # Priority for alias resolution
+    )
 
     # Core field attributes
-    name: str = Field(..., exclude=True)  # Field name (required)
+    name: str | UndefinedType = Field(
+        ..., exclude=True
+    )  # Field name (required)
     annotation: type | Any = Field(UNDEFINED, exclude=True)  # Type annotation
     validator: Callable | Any = Field(
         UNDEFINED, exclude=True
@@ -77,6 +91,18 @@ class FieldModel(SchemaModel):
         default_factory=dict, exclude=True
     )  # Validator parameters
 
+    @field_validator("validators", mode="before")
+    def _validate_validators(cls, v) -> list[Callable]:
+        if v is None or v is UNDEFINED:
+            return []
+        if isinstance(v, Callable):
+            return [v]
+        if isinstance(v, list) and is_same_dtype(v, Callable):
+            return v
+        raise ValueError(
+            "Validators must be a list of functions or a function"
+        )
+
     @property
     def field_info(self) -> FieldInfo:
         """Generate Pydantic FieldInfo object from field configuration.
@@ -92,7 +118,7 @@ class FieldModel(SchemaModel):
         annotation = (
             self.annotation if self.annotation is not UNDEFINED else Any
         )
-        field_obj: FieldInfo = Field(**self.to_dict(True))  # type: ignore
+        field_obj: FieldInfo = Field(**self.to_dict())  # type: ignore
         field_obj.annotation = annotation
         return field_obj
 
@@ -117,6 +143,3 @@ class FieldModel(SchemaModel):
                 self.validator
             )
         }
-
-
-__all__ = ["FieldModel"]

lionagi/core/models/{new_model_params.py → model_params.py}

@@ -9,7 +9,7 @@ from pydantic import BaseModel
 from lionagi.libs.parse import validate_boolean
 from lionagi.libs.utils import copy
 
-from ..typing.pydantic_ import (
+from ..typing._pydantic import (
     Field,
     FieldInfo,
     PrivateAttr,
@@ -17,12 +17,14 @@ from ..typing.pydantic_ import (
     field_validator,
     model_validator,
 )
-from ..typing.typing_ import Callable, Self
+from ..typing._typing import Callable, Self
 from .field_model import FieldModel
 from .schema_model import SchemaModel
 
+__all__ = ("ModelParams",)
 
-class NewModelParams(SchemaModel):
+
+class ModelParams(SchemaModel):
     """Configuration class for dynamically creating new Pydantic models."""
 
     name: str | None = None
@@ -190,6 +192,3 @@ class NewModelParams(SchemaModel):
         if self.frozen:
             a.model_config["frozen"] = True
         return a
-
-
-__all__ = ["NewModelParams"]

lionagi/core/models/note.py

@@ -5,8 +5,8 @@
 from lionagi.libs.parse import flatten, nget, ninsert, npop, nset, to_list
 from lionagi.libs.utils import copy
 
-from ..typing.pydantic_ import ConfigDict, Field, field_serializer
-from ..typing.typing_ import (
+from ..typing._pydantic import ConfigDict, Field, field_serializer
+from ..typing._typing import (
     UNDEFINED,
     Any,
     ItemsView,

lionagi/core/models/operable_model.py

@@ -4,7 +4,7 @@
 
 from lionagi.libs.utils import is_same_dtype
 
-from ..typing.pydantic_ import (
+from ..typing._pydantic import (
     ConfigDict,
     Field,
     FieldInfo,
@@ -12,8 +12,8 @@ from ..typing.pydantic_ import (
     field_serializer,
     field_validator,
 )
-from ..typing.typing_ import UNDEFINED, Any, TypeVar, override
-from .base import BaseAutoModel, common_config
+from ..typing._typing import UNDEFINED, Any, TypeVar, override
+from .base import BaseAutoModel
 from .field_model import FieldModel
 
 FIELD_NAME = TypeVar("FIELD_NAME", bound=str)
@@ -55,7 +55,11 @@ class OperableModel(BaseAutoModel):
     """
 
     model_config = ConfigDict(
-        extra="forbid", validate_default=False, **common_config
+        extra="forbid",
+        validate_default=False,
+        populate_by_name=True,
+        arbitrary_types_allowed=True,
+        use_enum_values=True,
     )
 
     extra_fields: dict[str, Any] = Field(default_factory=dict)

lionagi/core/models/schema_model.py

@@ -2,39 +2,20 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from ..typing.pydantic_ import ConfigDict
-from .base import BaseAutoModel, common_config
+from ..typing._pydantic import ConfigDict
+from .base import BaseAutoModel
 
+__all__ = ("SchemaModel",)
 
-class SchemaModel(BaseAutoModel):
-    """Schema definition model with strict validation.
-
-    Extends BaseAutoModel to provide:
-    - Extra field forbidding
-    - Disabled default validation
-    - Field name listing
-    - Nested validation
-
-    Example:
-        ```python
-        class UserSchema(SchemaModel):
-            name: str = Field(min_length=2)
-            age: int = Field(gt=0)
-            settings: dict[str, Any] = Field(default_factory=dict)
-
-        # Raises error - extra fields forbidden
-        user = UserSchema(name="John", age=30, extra="value")
-        ```
 
-    Attributes:
-        model_config: Schema-specific configuration
-            - extra: "forbid" to prevent extra fields
-            - validate_default: False to skip default validation
-            - Plus inherited BaseAutoModel config
-    """
+class SchemaModel(BaseAutoModel):
 
     model_config = ConfigDict(
-        extra="forbid", validate_default=False, **common_config
+        extra="forbid",
+        validate_default=False,
+        populate_by_name=True,
+        arbitrary_types_allowed=True,
+        use_enum_values=True,
     )
 
     @classmethod
@@ -45,6 +26,3 @@ class SchemaModel(BaseAutoModel):
             List of field names defined in model schema
         """
         return list(cls.model_fields.keys())
-
-
-__all__ = ["SchemaModel"]

lionagi/core/models/types.py

@@ -2,9 +2,18 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from .base import *
-from .field_model import *
-from .new_model_params import *
-from .note import *
-from .operable_model import *
-from .schema_model import *
+from .base import BaseAutoModel
+from .field_model import FieldModel
+from .model_params import ModelParams
+from .note import Note
+from .operable_model import OperableModel
+from .schema_model import SchemaModel
+
+__all__ = (
+    "BaseAutoModel",
+    "FieldModel",
+    "ModelParams",
+    "Note",
+    "OperableModel",
+    "SchemaModel",
+)

lionagi/core/session/branch.py

@@ -42,29 +42,33 @@ class Branch(Component, BranchActionMixin, BranchOperationMixin):
             )
         if not message_manager.logger:
             message_manager.logger = LogManager(
-                **Settings.Branch.BRANCH.message_log_config.to_dict(True)
+                **Settings.Branch.BRANCH.message_log_config.to_dict()
             )
 
         acts = data.pop("acts", None)
         if not acts:
             acts = ActionManager()
             acts.logger = LogManager(
-                **Settings.Branch.BRANCH.action_log_config.to_dict(True)
+                **Settings.Branch.BRANCH.action_log_config.to_dict()
             )
         if "tools" in data:
             acts.register_tools(data.pop("tools"))
 
         imodel = data.pop(
             "imodel",
-            LiteiModel(**Settings.iModel.CHAT),
+            iModel(**Settings.iModel.CHAT.to_dict()),
+        )
+        parse_imodel = data.pop(
+            "parse_imodel",
+            iModel(**Settings.iModel.PARSE.to_dict()),
         )
-
         out = {
             "user": user,
             "name": name,
             "msgs": message_manager,
             "acts": acts,
             "imodel": imodel,
+            "parse_imodel": parse_imodel,
             **data,
         }
         return out

lionagi/core/session/branch_mixins.py

@@ -14,13 +14,12 @@ from lionagi.core.typing import (
     UNDEFINED,
     BaseModel,
     FieldModel,
-    NewModelParams,
+    ModelParams,
 )
-from lionagi.integrations.litellm_.imodel import LiteiModel
 from lionagi.integrations.pydantic_ import break_down_pydantic_annotation
 from lionagi.libs.func.types import alcall
 from lionagi.libs.parse import to_json, validate_mapping
-from lionagi.protocols.operatives import (
+from lionagi.protocols.operatives.types import (
     ActionRequestModel,
     ActionResponseModel,
     Operative,
@@ -108,7 +107,7 @@ class BranchOperationMixin(ABC):
         recipient=None,
         operative_model: type[BaseModel] = None,
         progress=None,
-        imodel: iModel | LiteiModel = None,
+        imodel: iModel = None,
         reason: bool = False,
         actions: bool = False,
         exclude_fields: list | dict | None = None,
@@ -120,15 +119,15 @@ class BranchOperationMixin(ABC):
         images: list = None,
         image_detail: Literal["low", "high", "auto"] = None,
         max_retries: int = None,
-        retry_imodel: iModel | LiteiModel = None,
+        retry_imodel: iModel = None,
         retry_kwargs: dict = {},
         auto_retry_parse: bool = True,
         field_models: list[FieldModel] | None = None,
         skip_validation: bool = False,
         tools: str | Tool | list[Tool | str] | bool = None,
-        request_params: NewModelParams = None,
+        request_params: ModelParams = None,
         request_param_kwargs: dict = {},
-        response_params: NewModelParams = None,
+        response_params: ModelParams = None,
         response_param_kwargs: dict = {},
         **kwargs,
     ) -> list | BaseModel | None | dict | str:
@@ -269,7 +268,7 @@ class BranchOperationMixin(ABC):
         request_fields=None,
         request_model: type[BaseModel] = None,
         progress=None,
-        imodel: iModel | LiteiModel = None,
+        imodel: iModel = None,
         tool_schemas=None,
         images: list = None,
         image_detail: Literal["low", "high", "auto"] = None,
@@ -321,9 +320,9 @@ class BranchOperationMixin(ABC):
         imodel = imodel or self.imodel
         api_response = None
 
-        if isinstance(imodel, LiteiModel):
+        if not hasattr(imodel, "parse_to_data_model"):
             api_response = await imodel.invoke(**kwargs)
-        elif isinstance(imodel, iModel):
+        else:
             data_model = imodel.parse_to_data_model(**kwargs)
             api_response = await imodel.invoke(**data_model)
 
@@ -344,12 +343,12 @@ class BranchOperationMixin(ABC):
         progress: ID.IDSeq = None,
         request_model: type[BaseModel] | BaseModel = None,
         request_fields: dict | list[str] = None,
-        imodel: iModel | LiteiModel = None,
+        imodel: iModel = None,
         images: list = None,
         image_detail: Literal["low", "high", "auto"] = None,
         tools: str | FUNCTOOL | list[FUNCTOOL | str] | bool = None,
         num_parse_retries: int = 0,
-        retry_imodel: iModel | LiteiModel = None,
+        retry_imodel: iModel = None,
         retry_kwargs: dict = {},
         handle_validation: Literal[
             "raise", "return_value", "return_none"

lionagi/core/session/session.py

@@ -8,7 +8,6 @@ import pandas as pd
 
 from lionagi.core.generic.types import Component, Pile, Progression
 from lionagi.core.typing import ID, Field, ItemNotFoundError, JsonValue
-from lionagi.integrations.litellm_.imodel import LiteiModel
 from lionagi.libs.parse import to_list
 from lionagi.service import iModel
 
@@ -39,7 +38,7 @@ class Session(Component):
         system_datetime: bool | str = None,
         user: ID.SenderRecipient = None,
         name: str | None = None,
-        imodel: iModel | LiteiModel | None = None,
+        imodel: iModel | None = None,
         messages: Pile[RoledMessage] = None,
         progress: Progression = None,
         tool_manager: ActionManager = None,

lionagi/core/typing/__init__.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from ..models import *
-from .concepts import *
-from .id import *
-from .pydantic_ import *
-from .typing_ import *
+from ._concepts import *
+from ._id import *
+from ._pydantic import *
+from ._typing import *

lionagi/core/typing/{concepts.py → _concepts.py}

@@ -2,19 +2,59 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
+import uuid
 from abc import ABC, abstractmethod
+from dataclasses import dataclass
 from typing import Any, Generic, TypeVar
 
+from lionagi.settings import Settings
+
+
+class IDType:
+
+    def __init__(self, _id: uuid.UUID):
+        self._id = _id
+
+    @classmethod
+    def validate(cls, value) -> IDType:
+        if isinstance(value, cls):
+            return value
+        if isinstance(value, str | int):
+            try:
+                _id = uuid.UUID(value, version=Settings.Config.UUID_VERSION)
+                return cls(_id=_id)
+            except Exception as e:
+                raise ValueError(f"Invalid IDType value: {value}") from e
+        raise ValueError(f"Invalid IDType value: {value}")
+
+    def __str__(self):
+        return str(self._id)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self._id})"
+
+    def __hash__(self):
+        return hash(self._id)
+
+    def __eq__(self, other):
+        if not isinstance(other, IDType):
+            return False
+        return self._id == other._id
+
+    __slots__ = ("_id",)
+
 
 class Observable(ABC):
     """
     Abstract base class for objects that can be uniquely identified and tracked.
 
-    All Observable objects must have a unique identifier (ln_id) that allows them
+    All Observable objects must have a unique identifier (id) that allows them
     to be tracked and referenced within the Lion system.
     """
 
-    ln_id: str
+    ln_id: IDType
 
 
 T = TypeVar("T", bound=Observable)
@@ -129,4 +169,5 @@ __all__ = [
     "Condition",
     "Structure",
     "RelationError",
+    "IDType",
 ]

lionagi/core/typing/_id.py

@@ -0,0 +1,104 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import uuid
+
+from lionagi.settings import Settings
+
+from ._concepts import (
+    Container,
+    Generic,
+    IDType,
+    ItemError,
+    Observable,
+    Ordering,
+    T,
+)
+from ._typing import Container, Mapping, Sequence, TypeAlias
+
+
+class IDError(ItemError):
+    """Exception raised when an item does not have a Lion ID."""
+
+    def __init__(
+        self,
+        message: str = "Item must contain a Lion ID.",
+        item_id: str | None = None,
+    ):
+        super().__init__(message, item_id)
+
+
+class ID(Generic[T]):
+    """
+    A generic class that provides ID-related functionality for Observable objects.
+
+    This class handles the generation, validation, and management of unique identifiers
+    within the Lion system. It provides type aliases for various ID-related operations
+    and methods for working with IDs.
+    """
+
+    # For functions that accept either ID or item
+    Ref: TypeAlias = IDType | T  # type: ignore
+
+    # For functions requiring just the ID
+    ID: TypeAlias = IDType
+
+    # For functions requiring Observable object
+    Item = T  # type: ignore
+
+    # For collections
+    IDSeq: TypeAlias = list[IDType] | Ordering
+    ItemSeq: TypeAlias = (  # type: ignore
+        Sequence[T] | Mapping[IDType, T] | Container[IDType | T]
+    )
+    RefSeq: TypeAlias = IDSeq | ItemSeq
+
+    # For system-level interactions
+    SenderRecipient: TypeAlias = IDType | T | str  # type: ignore
+
+    @staticmethod
+    def id():
+        return IDType(
+            _id=getattr(uuid, f"uuid{Settings.Config.UUID_VERSION}")()
+        )
+
+    @staticmethod
+    def get_id(item, /) -> IDType:
+
+        if isinstance(item, Observable):
+            return item.ln_id
+        try:
+            return IDType.validate(item)
+        except ValueError as e:
+            raise IDError(
+                f"The input object of type <{type(item).__name__}> does "
+                "not contain or is not a valid Lion ID. Item must be an instance"
+                " of `Observable` or a valid `id`."
+            ) from e
+
+    @staticmethod
+    def is_id(item, /) -> bool:
+        """
+        Check if an item is or contains a valid Lion ID.
+
+        Args:
+            item: The item to check.
+            config: Configuration dictionary for ID validation.
+
+        Returns:
+            True if the item is a valid Lion ID, False otherwise.
+        """
+        try:
+            ID.get_id(item)
+            return True
+        except IDError:
+            return False
+
+
+__all__ = [
+    "ID",
+    "IDError",
+]

lionagi/integrations/anthropic_/AnthropicModel.py

@@ -4,7 +4,6 @@
 
 from pathlib import Path
 
-import yaml
 from dotenv import load_dotenv
 from pydantic import (
     BaseModel,
@@ -34,6 +33,12 @@ price_config_file_name = path / "anthropic_price_data.yaml"
 max_output_token_file_name = path / "anthropic_max_output_token_data.yaml"
 
 
+class _ModuleImportClass:
+    from lionagi.libs.package.imports import check_import
+
+    yaml = check_import("yaml", pip_name="pyyaml")
+
+
 class AnthropicModel(BaseModel):
     model: str = Field(description="ID of the model to use.")
 
@@ -234,7 +239,7 @@ class AnthropicModel(BaseModel):
         )
         if estimated_output_len == 0:
             with open(max_output_token_file_name) as file:
-                output_token_config = yaml.safe_load(file)
+                output_token_config = _ModuleImportClass.yaml.safe_load(file)
                 estimated_output_len = output_token_config.get(self.model, 0)
                 self.estimated_output_len = estimated_output_len
 
@@ -256,7 +261,7 @@ class AnthropicModel(BaseModel):
         num_of_input_tokens = self.text_token_calculator.calculate(input_text)
 
         with open(price_config_file_name) as file:
-            price_config = yaml.safe_load(file)
+            price_config = _ModuleImportClass.yaml.safe_load(file)
 
         model_price_info_dict = price_config["model"][self.model]
         estimated_price = (

lionagi/integrations/groq_/GroqModel.py

@@ -5,7 +5,6 @@
 import warnings
 from pathlib import Path
 
-import yaml
 from dotenv import load_dotenv
 from pydantic import (
     BaseModel,
@@ -34,6 +33,12 @@ max_output_token_file_name = path / "groq_max_output_token_data.yaml"
 rate_limits_file_name = path / "groq_rate_limits.yaml"
 
 
+class _ModuleImportClass:
+    from lionagi.libs.package.imports import check_import
+
+    yaml = check_import("yaml", pip_name="pyyaml")
+
+
 class GroqModel(BaseModel):
     model: str = Field(description="ID of the model to use.")
     request_model: GroqRequest = Field(description="Making requests")
@@ -67,7 +72,7 @@ class GroqModel(BaseModel):
         # Load rate limits from YAML
         try:
             with open(rate_limits_file_name) as file:
-                rate_limits = yaml.safe_load(file)
+                rate_limits = _ModuleImportClass.yaml.safe_load(file)
                 model_name = data.get("model")
                 model_limits = None
 
@@ -261,7 +266,9 @@ class GroqModel(BaseModel):
         if estimated_output_len == 0:
             try:
                 with open(max_output_token_file_name) as file:
-                    output_token_config = yaml.safe_load(file)
+                    output_token_config = _ModuleImportClass.yaml.safe_load(
+                        file
+                    )
                     estimated_output_len = output_token_config.get(
                         self.model, 2048
                     )  # Default to 2048
@@ -297,7 +304,7 @@ class GroqModel(BaseModel):
 
         try:
             with open(price_config_file_name) as file:
-                price_config = yaml.safe_load(file)
+                price_config = _ModuleImportClass.yaml.safe_load(file)
         except FileNotFoundError:
             raise ValueError(
                 f"Price config file not found: {price_config_file_name}"