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

lionagi/__init__.py

@@ -5,7 +5,6 @@ import logging
 from dotenv import load_dotenv
 
 from .core.session.types import Branch
-from .integrations.litellm_.imodel import LiteiModel
 from .protocols.operatives.step import Step
 from .service import iModel
 from .settings import Settings

lionagi/core/action/tool.py

@@ -138,12 +138,10 @@ class Tool(Element):
         Returns:
             str: A detailed string representation of the Tool.
         """
-        timestamp_str = datetime.fromtimestamp(self.timestamp).isoformat(
-            timespec="minutes"
-        )
+        timestamp_str = self.created_datetime.strftime("%Y-%m-%d %H:%M:%S")
         return (
-            f"{self.class_name()}(ln_id={self.ln_id[:6]}.., "
-            f"timestamp={timestamp_str}), "
+            f"{self.class_name()}(ln_id={str(self.ln_id)[:6]}.., "
+            f"created_timestamp={timestamp_str}), "
             f"schema_={json.dumps(self.schema_, indent=4)}"
         )
 

lionagi/core/communication/action_request.py

@@ -4,7 +4,7 @@
 
 from typing_extensions import override
 
-from lionagi.core.typing import ID, Any, Callable, LnID, Note
+from lionagi.core.typing import ID, Any, Callable, IDType, Note
 from lionagi.libs.parse import to_dict
 from lionagi.libs.utils import copy
 
@@ -107,12 +107,12 @@ class ActionRequest(RoledMessage):
         )
 
     @property
-    def action_response_id(self) -> LnID | None:
+    def action_response_id(self) -> IDType | None:
         """
         Get the ID of the corresponding action response.
 
         Returns:
-            LnID | None: The ID of the action response, or None if not responded
+            IDType | None: The ID of the action response, or None if not responded
         """
         return self.content.get("action_response_id", None)
 

lionagi/core/communication/message.py

@@ -58,7 +58,7 @@ class MessageField(str, Enum):
     - LION_CLASS: Class identifier for LION system
     - ROLE: Message role (system/user/assistant)
     - CONTENT: Message content
-    - ln_id: Unique message identifier
+    - id: Unique message identifier
     - SENDER: Message sender
     - RECIPIENT: Message recipient
     - METADATA: Additional message metadata
@@ -68,7 +68,7 @@ class MessageField(str, Enum):
     LION_CLASS = "lion_class"
     ROLE = "role"
     CONTENT = "content"
-    ln_id = "ln_id"
+    id = "id"
     SENDER = "sender"
     RECIPIENT = "recipient"
     METADATA = "metadata"
@@ -248,7 +248,7 @@ class RoledMessage(Component, BaseMail):
         if origin_obj and isinstance(origin_obj, Communicatable):
             info_dict = {
                 "clone_from_info": {
-                    "original_ln_id": origin_obj.ln_id,
+                    "original_id": origin_obj.id,
                     "original_timestamp": origin_obj.timestamp,
                     "original_sender": origin_obj.sender,
                     "original_recipient": origin_obj.recipient,

lionagi/core/communication/utils.py

@@ -8,8 +8,8 @@ from lionagi.core.typing import (
     Any,
     BaseModel,
     IDError,
+    IDType,
     Literal,
-    LnID,
     Note,
 )
 from lionagi.integrations.pydantic_ import break_down_pydantic_annotation
@@ -229,7 +229,7 @@ def prepare_instruction_content(
 
 def validate_sender_recipient(
     value: Any, /
-) -> LnID | Literal["system", "user", "N/A", "assistant"]:
+) -> IDType | Literal["system", "user", "N/A", "assistant"]:
     """
     Validate sender and recipient fields for mail-like communication.
 
@@ -237,7 +237,7 @@ def validate_sender_recipient(
         value: The value to validate
 
     Returns:
-        Union[LnID, Literal]: Valid sender/recipient value
+        Union[IDType, Literal]: Valid sender/recipient value
 
     Raises:
         ValueError: If value is not a valid sender or recipient

lionagi/core/generic/component.py

@@ -289,8 +289,8 @@ class Component(Element, OperableModel):
 
         output_str = (
             f"{self.__class__.__name__}("
-            f"ln_id={self.ln_id[:8]}..., "
-            f"timestamp={str(self.created_datetime)[:-6]}, "
+            f"ln_id={str(self.ln_id)[:8]}..., "
+            f"created_timestamp={str(self.created_datetime)[:-6]}, "
             f"content='{content_preview}', "
             f"metadata_keys={list(self.metadata.keys())}, "
         )
@@ -340,8 +340,8 @@ class Component(Element, OperableModel):
 
         repr_str = (
             f"{self.class_name()}("
-            f"ln_id={repr(self.ln_id)}, "
-            f"timestamp={str(self.created_datetime)[:-6]}, "
+            f"ln_id=IDType({str(self.ln_id)}), "
+            f"created_timestamp={str(self.created_datetime)[:-6]}, "
             f"content={content_repr}, "
             f"metadata={truncate_dict(self.metadata.content)}, "
         )

lionagi/core/generic/element.py

@@ -4,6 +4,8 @@
 
 from datetime import datetime
 
+from pydantic import AliasChoices, field_serializer
+
 from lionagi.core._class_registry import LION_CLASS_REGISTRY, get_class
 from lionagi.core.typing import (
     ID,
@@ -12,8 +14,7 @@ from lionagi.core.typing import (
     ConfigDict,
     Field,
     IDError,
-    LnID,
-    Note,
+    IDType,
     Observable,
     TypeVar,
     field_validator,
@@ -48,32 +49,45 @@ class Element(BaseModel, Observable):
         - String formatting
 
     Attributes:
-        ln_id (LnID): Unique identifier for the element. Generated automatically
+        id (IDType): Unique identifier for the element. Generated automatically
             and immutable.
         timestamp (float): Creation timestamp as Unix timestamp. Generated
             automatically and immutable.
     """
 
-    ln_id: LnID = Field(
+    model_config = ConfigDict(
+        extra="forbid",
+        arbitrary_types_allowed=True,
+        use_enum_values=True,
+        populate_by_name=True,
+    )
+
+    ln_id: IDType = Field(
         default_factory=ID.id,
         title="Lion ID",
         description="Unique identifier for the element",
         frozen=True,
     )
 
-    timestamp: float = Field(
-        default_factory=lambda: time(type_="timestamp"),
-        title="Creation Timestamp",
+    created_timestamp: float = Field(
+        default_factory=lambda: time(
+            tz=Settings.Config.TIMEZONE, type_="timestamp"
+        ),
+        title="Creation Datetime",
         frozen=True,
-        alias="created",
+        alias=AliasChoices("created_at", "timestamp"),
     )
 
-    model_config = ConfigDict(
-        extra="forbid",
-        arbitrary_types_allowed=True,
-        use_enum_values=True,
-        populate_by_name=True,
-    )
+    @property
+    def created_datetime(self) -> datetime:
+        """Get the creation timestamp as a Unix timestamp.
+
+        Returns:
+            float: The creation timestamp.
+        """
+        return datetime.fromtimestamp(
+            self.created_timestamp, tz=Settings.Config.TIMEZONE
+        )
 
     @classmethod
     def class_name(cls) -> str:
@@ -89,41 +103,39 @@ class Element(BaseModel, Observable):
         super().__pydantic_init_subclass__(**kwargs)
         LION_CLASS_REGISTRY[cls.__name__] = cls
 
-    @property
-    def created_datetime(self) -> datetime:
-        """Get the creation datetime of the Element.
-
-        Converts the Unix timestamp to a timezone-aware datetime object using the
-        timezone specified in Settings.Config.TIMEZONE.
-
-        Returns:
-            datetime: A timezone-aware datetime object representing when the
-                Element was created.
-        """
-        return datetime.fromtimestamp(
-            self.timestamp, tz=Settings.Config.TIMEZONE
-        )
+    @field_serializer("ln_id")
+    def _serialize_id(self, value: IDType) -> str:
+        return str(self.ln_id)
 
     @field_validator("ln_id", mode="before")
-    def _validate_id(cls, value: ID.ID) -> str:
+    def _validate_id(cls, value: str | IDType) -> str:
         try:
             return ID.get_id(value)
         except Exception:
             raise IDError(f"Invalid lion id: {value}")
 
-    @field_validator("timestamp", mode="before")
+    @field_validator("created_timestamp", mode="before")
     def _validate_timestamp(cls, value: Any) -> float:
-        if isinstance(value, (int, float)):
-            return float(value)
         if isinstance(value, datetime):
             return value.timestamp()
-        try:
-            if isinstance(value, str):
+
+        if isinstance(value, int | float):
+            return value
+
+        if isinstance(value, str):
+            try:
+                return datetime.fromisoformat(value).timestamp()
+            except Exception as e:
                 try:
-                    return float(value)
+                    value = float(value)
                 except Exception:
-                    return datetime.fromisoformat(value).timestamp()
-            raise ValueError
+                    raise ValueError(
+                        f"Invalid datetime string format: {value}"
+                    ) from e
+
+        try:
+            return datetime.fromtimestamp(value, tz=Settings.Config.TIMEZONE)
+
         except Exception as e:
             raise ValueError(f"Invalid datetime string format: {value}") from e
 
@@ -170,8 +182,8 @@ class Element(BaseModel, Observable):
     def __str__(self) -> str:
         timestamp_str = self.created_datetime.isoformat(timespec="minutes")
         return (
-            f"{self.class_name()}(ln_id={self.ln_id[:6]}.., "
-            f"timestamp={timestamp_str})"
+            f"{self.class_name()}(ln_id={str(self.ln_id)[:6]}.., "
+            f"created_timestamp={timestamp_str})"
         )
 
     def __hash__(self) -> int:
@@ -183,13 +195,5 @@ class Element(BaseModel, Observable):
     def __len__(self) -> int:
         return 1
 
-    def to_note(self) -> Note:
-        """Convert Log to Note.
-
-        Returns:
-            Note representation of the log
-        """
-        return Note(**self.to_dict())
-
 
 __all__ = ["Element"]

lionagi/core/generic/graph.py

@@ -281,7 +281,7 @@ class Graph(Node):
             node_info.update({"class_name": node.class_name()})
             if hasattr(node, "name"):
                 node_info.update({"name": node.name})
-            g.add_node(node.ln_id, **node_info)
+            g.add_node(str(node.ln_id), **node_info)
 
         for _edge in self.internal_edges:
             edge_info = _edge.to_dict()

lionagi/core/generic/log.py

@@ -72,7 +72,7 @@ class Log(Element):
             if "log_id" in data:
                 data["ln_id"] = data.pop("log_id")
             if "log_timestamp" in data:
-                data["timestamp"] = data.pop("log_timestamp")
+                data["created_timestamp"] = data.pop("log_timestamp")
             if "log_class" in data:
                 data["lion_class"] = data.pop("log_class")
             return data
@@ -140,7 +140,7 @@ class Log(Element):
         # Convert standard fields to log_* fields
         dict_["log_id"] = dict_.pop("ln_id")
         dict_["log_class"] = dict_.pop("lion_class")
-        dict_["log_timestamp"] = dict_.pop("timestamp")
+        dict_["log_timestamp"] = dict_.pop("created_timestamp")
 
         dict_ = to_dict(
             dict_,

lionagi/core/generic/pile.py

@@ -26,6 +26,7 @@ from lionagi.core.typing import (
     TypeVar,
     field_serializer,
 )
+from lionagi.core.typing._concepts import IDType
 from lionagi.libs.parse import is_same_dtype, to_list
 from lionagi.protocols.adapters.adapter import Adapter, AdapterRegistry
 from lionagi.protocols.registries._pile_registry import PileAdapterRegistry
@@ -38,6 +39,9 @@ T = TypeVar("T", bound=Element)
 D = TypeVar("D")
 
 
+__all__ = ("Pile", "pile")
+
+
 def synchronized(func: Callable):
     @wraps(func)
     def wrapper(self: "Pile", *args, **kwargs):
@@ -72,7 +76,7 @@ class Pile(Element, Generic[T]):
         strict_type (bool): Whether to enforce strict type checking
     """
 
-    pile_: dict[str, T] = Field(default_factory=dict)
+    pile_: dict[IDType, T] = Field(default_factory=dict)
     item_type: set[type[T]] | None = Field(
         default=None,
         description="Set of allowed types for items in the pile.",
@@ -120,8 +124,8 @@ class Pile(Element, Generic[T]):
         _config = {}
         if "ln_id" in kwargs:
             _config["ln_id"] = kwargs["ln_id"]
-        if "created" in kwargs:
-            _config["created"] = kwargs["created"]
+        if "created_timestamp" in kwargs:
+            _config["created_timestamp"] = kwargs["created_timestamp"]
 
         super().__init__(strict_type=strict_type, **_config)
         self.item_type = self._validate_item_type(item_type)
@@ -303,7 +307,7 @@ class Pile(Element, Generic[T]):
         """Get all items in order."""
         return [self.pile_[key] for key in self.progress]
 
-    def items(self) -> Sequence[tuple[str, T]]:
+    def items(self) -> Sequence[tuple[IDType, T]]:
         """Get all (ID, item) pairs in order."""
         return [(key, self.pile_[key]) for key in self.progress]
 
@@ -619,7 +623,7 @@ class Pile(Element, Generic[T]):
             except Exception as e:
                 raise ItemNotFoundError(f"index {key}. Error: {e}")
 
-        elif isinstance(key, str):
+        elif isinstance(key, IDType):
             try:
                 return self.pile_[key]
             except Exception as e:
@@ -724,7 +728,7 @@ class Pile(Element, Generic[T]):
         if isinstance(key, int | slice):
             try:
                 pops = self.progress[key]
-                pops = [pops] if isinstance(pops, str) else pops
+                pops = [pops] if isinstance(pops, IDType) else pops
                 result = []
                 for i in pops:
                     self.progress.remove(i)
@@ -965,10 +969,6 @@ class Pile(Element, Generic[T]):
         """Save to CSV file."""
         self.adapt_to(".csv", fp=fp, **kwargs)
 
-    def to_excel(self, fp: str | Path, **kwargs: Any) -> None:
-        """Save to Excel file."""
-        self.adapt_to(".xlsx", fp=fp, **kwargs)
-
 
 def pile(
     items: Any = None,
@@ -1013,5 +1013,4 @@ def pile(
     )
 
 
-__all__ = [Pile, pile]
 # File: autoos/generic/pile.py

lionagi/core/generic/progression.py

@@ -6,15 +6,18 @@ import contextlib
 from collections.abc import Iterator
 from typing import Any, Self
 
-from pydantic import field_validator
+from pydantic import field_serializer, field_validator
 from typing_extensions import override
 
-from lionagi.core.typing import ID, Field, ItemNotFoundError, LnID, Ordering
+from lionagi.core.typing import ID, Field, IDType, ItemNotFoundError, Ordering
+from lionagi.core.typing._concepts import Observable
 from lionagi.libs.parse import to_list
 
 from .element import Element
 from .utils import to_list_type, validate_order
 
+__all__ = ("Progression", "prog")
+
 
 class Progression(Element, Ordering):
     """A flexible, ordered sequence container for Lion IDs.
@@ -41,14 +44,18 @@ class Progression(Element, Ordering):
         description="The name of the progression.",
     )
 
-    order: list[ID.ID] = Field(
+    order: list[IDType] = Field(
         default_factory=list,
         title="Order",
         description="The order of the progression.",
     )
 
+    @field_serializer("order")
+    def _serialize_order(self, value: list[IDType]) -> list[str]:
+        return [str(i) for i in self.order]
+
     @field_validator("order", mode="before")
-    def _validate_order(cls, value: ID.RefSeq) -> list[LnID]:
+    def _validate_order(cls, value: ID.RefSeq) -> list[IDType]:
         if not value:
             return []
         try:
@@ -66,15 +73,15 @@ class Progression(Element, Ordering):
         check = False
         for i in item:
             check = False
-            if isinstance(i, str):
+            if isinstance(i, IDType):
                 check = i in self.order
-            elif isinstance(i, Element):
+            elif isinstance(i, Observable):
                 check = i.ln_id in self.order
             if not check:
                 return False
         return check
 
-    def __list__(self) -> list[LnID]:
+    def __list__(self) -> list[IDType]:
         """Return a copy of the order."""
         return self.order[:]
 
@@ -127,11 +134,11 @@ class Progression(Element, Ordering):
         """Delete an item or slice of items from the progression."""
         del self.order[key]
 
-    def __iter__(self) -> Iterator[LnID]:
+    def __iter__(self) -> Iterator[IDType]:
         """Iterate over the items in the progression."""
         return iter(self.order)
 
-    def __next__(self) -> LnID:
+    def __next__(self) -> IDType:
         """Return the next item in the progression."""
         try:
             return next(iter(self.order))
@@ -155,7 +162,7 @@ class Progression(Element, Ordering):
         item_ = validate_order(item)
         self.order.extend(item_)
 
-    def pop(self, index: int = None, /) -> str:
+    def pop(self, index: int = None, /) -> IDType:
         """Remove and return an item from the progression.
 
         Args:
@@ -255,7 +262,7 @@ class Progression(Element, Ordering):
 
         raise ItemNotFoundError(f"{item}")
 
-    def popleft(self) -> str:
+    def popleft(self) -> IDType:
         """Remove and return the leftmost item from the progression.
 
         Returns:
@@ -371,7 +378,7 @@ class Progression(Element, Ordering):
         return hash(self.ln_id)
 
 
-def progression(
+def prog(
     order: ID.RefSeq = None,
     name: str = None,
     /,

lionagi/core/generic/utils.py

@@ -7,6 +7,7 @@ from collections.abc import Generator
 from typing import Any, TypeVar
 
 from lionagi.core.typing import ID, IDError
+from lionagi.core.typing._concepts import IDType, Observable
 
 from .element import Element
 
@@ -17,8 +18,10 @@ def to_list_type(value: Any, /) -> list[Any]:
     """Convert input to a list format"""
     if value is None:
         return []
+    if isinstance(value, IDType):
+        return [value]
     if isinstance(value, str):
-        return [value] if ID.is_id(value) else []
+        return ID.get_id(value) if ID.is_id(value) else []
     if isinstance(value, Element):
         return [value]
     if hasattr(value, "values") and callable(value.values):
@@ -35,8 +38,8 @@ def validate_order(value: Any, /) -> list[str]:
         result = []
         for item in to_list_type(value):
             if isinstance(item, str) and ID.is_id(item):
-                result.append(item)
-            elif isinstance(item, Element):
+                result.append(ID.get_id(item))
+            elif isinstance(item, Observable):
                 result.append(item.ln_id)
             else:
                 id_ = ID.get_id(item)

lionagi/core/models/base.py

@@ -2,84 +2,27 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from ..typing.pydantic_ import BaseModel
-from ..typing.typing_ import UNDEFINED, Any, Self
+from ..typing._pydantic import BaseModel
+from ..typing._typing import UNDEFINED, Any, Self
 
-common_config = {
-    "populate_by_name": True,
-    "arbitrary_types_allowed": True,
-    "use_enum_values": True,
-}
+__all__ = ("BaseAutoModel",)
 
 
 class BaseAutoModel(BaseModel):
-    """Base model class with enhanced serialization capabilities.
+    """a hashable pydantic model interface with to_dict and from_dict method"""
 
-    Extends Pydantic's BaseModel to provide:
-    - Clean dictionary conversion with UNDEFINED handling
-    - Nested model serialization
-    - Hash generation based on model content
-    - Validation rules
-
-    Example:
-        ```python
-        class User(BaseAutoModel):
-            name: str = Field(min_length=2)
-            age: int | None = None
-            settings: dict = Field(default_factory=dict)
-
-        user = User(name="John", age=30)
-        data = user.to_dict(clean=True)  # Excludes UNDEFINED values
-        ```
-
-    Attributes:
-        model_config: Default configuration for all instances
-            - validate_default: True to validate default values
-            - populate_by_name: True to allow field population by alias
-            - arbitrary_types_allowed: True to allow any type
-            - use_enum_values: True to use enum values in serialization
-    """
-
-    def to_dict(self, clean: bool = False) -> dict[str, Any]:
-        """Convert model to dictionary, with optional cleaning.
-
-        Args:
-            clean: If True, exclude UNDEFINED values from output.
-                  If False, include all fields using model_dump().
-
-        Returns:
-            Dictionary representation of model with nested models serialized
-        """
-        if not clean:
-            return self.model_dump()
+    def to_dict(self, **kwargs) -> dict[str, Any]:
+        """kwargs for pydantic model_dump()"""
         return {
             k: v
-            for k, v in self.model_dump(exclude_unset=True).items()
+            for k, v in self.model_dump(**kwargs).items()
             if v is not UNDEFINED
         }
 
     @classmethod
-    def from_dict(cls, data: dict) -> Self:
-        """Create model instance from dictionary data.
-
-        Args:
-            data: Dictionary containing field values
-
-        Returns:
-            New model instance
-
-        Raises:
-            ValueError: If required fields are missing or validation fails
-        """
-        return cls.model_validate(data)
+    def from_dict(cls, data: dict, **kwargs) -> Self:
+        """kwargs for model_validate"""
+        return cls.model_validate(data, **kwargs)
 
     def __hash__(self) -> int:
-        """Generate hash based on model's clean dictionary representation.
-
-        Returns:
-            Hash value that uniquely identifies the model's content
-        """
-        return hash(str(self.to_dict(True)))
-
-
-__all__ = ["BaseAutoModel"]
+        return hash(str(self.to_dict()))