lionagi 0.15.8__py3-none-any.whl → 0.15.11__py3-none-any.whl

lionagi/protocols/generic/event.py

@@ -2,14 +2,15 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
 import contextlib
-import json
 from enum import Enum
 from typing import Any
 
 from pydantic import Field, field_serializer
 
-from lionagi.ln import Unset
+from lionagi import ln
 from lionagi.utils import to_dict
 
 from .element import Element
@@ -24,7 +25,7 @@ __all__ = (
 _SIMPLE_TYPE = (str, bytes, bytearray, int, float, type(None), Enum)
 
 
-class EventStatus(str, Enum):
+class EventStatus(str, ln.Enum):
     """Status states for tracking action execution progress.
 
     Attributes:
@@ -95,29 +96,30 @@ class Execution:
         Returns:
             dict: A dictionary representation of the execution state.
         """
-        res_ = Unset
+        res_ = ln.Unset
         json_serializable = True
 
         if not isinstance(self.response, _SIMPLE_TYPE):
             json_serializable = False
             try:
                 # check whether response is JSON serializable
-                json.dumps(self.response)
+                ln.json_dumps(self.response)
                 res_ = self.response
                 json_serializable = True
             except Exception:
                 with contextlib.suppress(Exception):
-                    # attempt to convert to dict
+                    # attempt to force convert to dict
                     d_ = to_dict(
                         self.response,
                         recursive=True,
                         recursive_python_only=False,
+                        use_enum_values=True,
                     )
-                    json.dumps(d_)
+                    ln.json_dumps(d_)
                     res_ = d_
                     json_serializable = True
 
-        if res_ is Unset and not json_serializable:
+        if res_ is ln.Unset and not json_serializable:
             res_ = "<unserializable>"
 
         return {
@@ -140,93 +142,70 @@ class Event(Element):
 
     @field_serializer("execution")
     def _serialize_execution(self, val: Execution) -> dict:
-        """Serializes the Execution object into a dictionary.
-
-        Args:
-            val (Execution): The Execution object to serialize.
-
-        Returns:
-            dict: The serialized data containing status, duration, response,
-            and error fields.
-        """
+        """Serializes the Execution object into a dictionary."""
         return val.to_dict()
 
     @property
     def response(self) -> Any:
-        """Gets or sets the execution response.
-
-        Returns:
-            Any: The current response for this event.
-        """
+        """Gets or sets the execution response."""
         return self.execution.response
 
     @response.setter
     def response(self, val: Any) -> None:
-        """Sets the execution response.
-
-        Args:
-            val (Any): The new response value for this event.
-        """
+        """Sets the execution response."""
         self.execution.response = val
 
     @property
     def status(self) -> EventStatus:
-        """Gets or sets the event status.
-
-        Returns:
-            EventStatus: The current status of this event.
-        """
+        """Gets or sets the event status."""
         return self.execution.status
 
     @status.setter
-    def status(self, val: EventStatus) -> None:
-        """Sets the event status.
-
-        Args:
-            val (EventStatus): The new status for the event.
-        """
-        self.execution.status = val
+    def status(self, val: EventStatus | str) -> None:
+        """Sets the event status."""
+        if isinstance(val, str):
+            if val not in EventStatus.allowed():
+                raise ValueError(f"Invalid status: {val}")
+            val = EventStatus(val)
+        if isinstance(val, EventStatus):
+            self.execution.status = val
+        else:
+            raise ValueError(
+                f"Invalid status type: {type(val)}. Expected EventStatus or str."
+            )
 
     @property
     def request(self) -> dict:
-        """Gets the request for this event.
-
-        Returns:
-            dict: An empty dictionary by default. Override in subclasses
-            if needed.
-        """
+        """Gets the request for this event. Override in subclasses"""
         return {}
 
     async def invoke(self) -> None:
-        """Performs the event action asynchronously.
-
-        Raises:
-            NotImplementedError: This base method must be overridden by
-            subclasses.
-        """
+        """Performs the event action asynchronously."""
         raise NotImplementedError("Override in subclass.")
 
     async def stream(self) -> None:
-        """Performs the event action asynchronously, streaming results.
-
-        Raises:
-            NotImplementedError: This base method must be overridden by
-            subclasses.
-        """
+        """Performs the event action asynchronously, streaming results."""
         raise NotImplementedError("Override in subclass.")
 
     @classmethod
-    def from_dict(cls, data: dict) -> "Event":
-        """Not implemented. Events cannot be fully recreated once done.
-
-        Args:
-            data (dict): Event data (unused).
-
-        Raises:
-            NotImplementedError: Always, because recreating an event is
-            disallowed.
-        """
+    def from_dict(cls, data: dict) -> Event:
+        """Not implemented. Events cannot be fully recreated once done."""
         raise NotImplementedError("Cannot recreate an event once it's done.")
 
+    def as_fresh_event(self, copy_meta: bool = False) -> Event:
+        """Creates a clone of this event with the same execution state."""
+        d_ = self.to_dict()
+        for i in ["execution", "created_at", "id", "metadata"]:
+            d_.pop(i, None)
+        fresh = self.__class__(**d_)
+        if copy_meta:
+            meta = self.metadata.copy()
+            fresh.metadata = meta
+        fresh.metadata["original"] = {
+            "id": str(self.id),
+            "created_at": self.created_at,
+        }
+        return fresh
+
 
 # File: lionagi/protocols/generic/event.py

lionagi/protocols/generic/pile.py

@@ -19,7 +19,7 @@ from pathlib import Path
 from typing import Any, ClassVar, Generic, Literal, TypeVar
 
 import pandas as pd
-from pydantic import Field, field_serializer, field_validator, model_validator
+from pydantic import Field, field_serializer
 from pydantic.fields import FieldInfo
 from pydapter import Adaptable, AsyncAdaptable
 from typing_extensions import Self, deprecated, override
@@ -988,6 +988,12 @@ class Pile(Element, Collective[T], Generic[T], Adaptable, AsyncAdaptable):
             is_same_dtype(self.collections.values())
         )
 
+    @classmethod
+    def list_adapters(cls) -> list[str]:
+        syn_ = cls._adapter_registry._reg.keys()
+        asy_ = cls._async_registry._reg.keys()
+        return list(set(syn_) | set(asy_))
+
     def adapt_to(self, obj_key: str, many=False, **kw: Any) -> Any:
         """Adapt to another format.
 
@@ -1132,6 +1138,55 @@ class Pile(Element, Collective[T], Generic[T], Adaptable, AsyncAdaptable):
     ) -> None:
         return self.dump(fp, obj_key=obj_key, mode=mode, clear=clear, **kw)
 
+    def filter_by_type(
+        self,
+        item_type: type[T] | list | set,
+        strict_type: bool = False,
+        as_pile: bool = False,
+        reverse: bool = False,
+        num_items: int | None = None,
+    ) -> list[T]:
+        if isinstance(item_type, type):
+            if is_union_type(item_type):
+                item_type = set(union_members(item_type))
+            else:
+                item_type = {item_type}
+
+        if isinstance(item_type, list | tuple):
+            item_type = set(item_type)
+
+        if not isinstance(item_type, set):
+            raise TypeError("item_type must be a type or a list/set of types")
+
+        meth = None
+
+        if strict_type:
+            meth = lambda item: type(item) in item_type
+        else:
+            meth = (
+                lambda item: any(isinstance(item, t) for t in item_type)
+                is True
+            )
+
+        out = []
+        prog = (
+            list(self.progression)
+            if not reverse
+            else reversed(list(self.progression))
+        )
+        for i in prog:
+            item = self.collections[i]
+            if meth(item):
+                out.append(item)
+            if num_items is not None and len(out) == num_items:
+                break
+
+        if as_pile:
+            return self.__class__(
+                collections=out, item_type=item_type, strict_type=strict_type
+            )
+        return out
+
 
 def to_list_type(value: Any, /) -> list[Any]:
     """Convert input to a list format"""

lionagi/protocols/generic/progression.py

@@ -14,7 +14,7 @@ from lionagi._errors import ItemNotFoundError
 from .._concepts import Ordering
 from .element import ID, Element, IDError, IDType, validate_order
 
-E = TypeVar("E", bound=Element)
+T = TypeVar("T", bound=Element)
 
 
 __all__ = (
@@ -23,7 +23,7 @@ __all__ = (
 )
 
 
-class Progression(Element, Ordering[E], Generic[E]):
+class Progression(Element, Ordering[T], Generic[T]):
     """Tracks an ordered sequence of item IDs, with optional naming.
 
     This class extends `Element` and implements `Ordering`, providing
@@ -39,7 +39,7 @@ class Progression(Element, Ordering[E], Generic[E]):
             An optional human-readable identifier for the progression.
     """
 
-    order: list[ID[E].ID] = Field(
+    order: list[ID[T].ID] = Field(
         default_factory=list,
         title="Order",
         description="A sequence of IDs representing the progression.",
@@ -358,7 +358,7 @@ class Progression(Element, Ordering[E], Generic[E]):
             raise ValueError("Can only extend with another Progression.")
         self.order.extend(other.order)
 
-    def __add__(self, other: Any) -> Progression[E]:
+    def __add__(self, other: Any) -> Progression[T]:
         """Returns a new Progression with IDs from both this and `other`.
 
         Args:
@@ -371,7 +371,7 @@ class Progression(Element, Ordering[E], Generic[E]):
         new_refs = validate_order(other)
         return Progression(order=self.order + new_refs)
 
-    def __radd__(self, other: Any) -> Progression[E]:
+    def __radd__(self, other: Any) -> Progression[T]:
         """Returns a new Progression with IDs from `other` + this.
 
         Args:
@@ -396,7 +396,7 @@ class Progression(Element, Ordering[E], Generic[E]):
         self.append(other)
         return self
 
-    def __sub__(self, other: Any) -> Progression[E]:
+    def __sub__(self, other: Any) -> Progression[T]:
         """Returns a new Progression excluding specified IDs.
 
         Args:
@@ -435,7 +435,7 @@ class Progression(Element, Ordering[E], Generic[E]):
         for i in reversed(item_):
             self.order.insert(index, ID.get_id(i))
 
-    def __reverse__(self) -> Progression[E]:
+    def __reversed__(self) -> Progression[T]:
         """Returns a new reversed Progression.
 
         Returns:
@@ -456,19 +456,19 @@ class Progression(Element, Ordering[E], Generic[E]):
             return NotImplemented
         return (self.order == other.order) and (self.name == other.name)
 
-    def __gt__(self, other: Progression[E]) -> bool:
+    def __gt__(self, other: Progression[T]) -> bool:
         """Compares if this progression is "greater" by ID order."""
         return self.order > other.order
 
-    def __lt__(self, other: Progression[E]) -> bool:
+    def __lt__(self, other: Progression[T]) -> bool:
         """Compares if this progression is "less" by ID order."""
         return self.order < other.order
 
-    def __ge__(self, other: Progression[E]) -> bool:
+    def __ge__(self, other: Progression[T]) -> bool:
         """Compares if this progression is >= the other by ID order."""
         return self.order >= other.order
 
-    def __le__(self, other: Progression[E]) -> bool:
+    def __le__(self, other: Progression[T]) -> bool:
         """Compares if this progression is <= the other by ID order."""
         return self.order <= other.order
 

lionagi/protocols/graph/_utils.py

@@ -0,0 +1,22 @@
+def check_networkx_available():
+    try:
+        from networkx import DiGraph  # noqa: F401
+
+        return True
+    except Exception:
+        return ImportError(
+            "The 'networkx' package is required for this feature. "
+            "Please install `networkx` or `'lionagi[graph]'`."
+        )
+
+
+def check_matplotlib_available():
+    try:
+        import matplotlib.pyplot as plt
+
+        return True
+    except Exception:
+        return ImportError(
+            "The 'matplotlib' package is required for this feature. "
+            "Please install `matplotlib` or `'lionagi[graph]'`."
+        )

lionagi/protocols/graph/graph.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from collections import deque
-from typing import Any, Literal
+from typing import Any, Generic, Literal, TypeVar
 
 from pydantic import Field, field_serializer, field_validator, model_validator
 from typing_extensions import Self
@@ -17,11 +17,17 @@ from ..generic.pile import Pile
 from .edge import Edge
 from .node import Node
 
+T = TypeVar("T", bound=Node)
+
+from ._utils import check_matplotlib_available, check_networkx_available
+
+_NETWORKX_AVAILABLE = check_networkx_available()
+_MATPLIB_AVAILABLE = check_matplotlib_available()
 __all__ = ("Graph",)
 
 
-class Graph(Element, Relational):
-    internal_nodes: Pile[Node] = Field(
+class Graph(Element, Relational, Generic[T]):
+    internal_nodes: Pile[T] = Field(
         default_factory=lambda: Pile(item_type={Node}, strict_type=False),
         title="Internal Nodes",
         description="A collection of nodes in the graph.",
@@ -214,13 +220,10 @@ class Graph(Element, Relational):
 
     def to_networkx(self, **kwargs) -> Any:
         """Convert the graph to a NetworkX graph object."""
-        try:
-            from networkx import DiGraph  # type: ignore
+        if _NETWORKX_AVAILABLE is not True:
+            raise _NETWORKX_AVAILABLE
 
-        except ImportError:
-            from lionagi.libs.package.imports import check_import
-
-            DiGraph = check_import("networkx", import_name="DiGraph")
+        from networkx import DiGraph  # type: ignore
 
         g = DiGraph(**kwargs)
         for node in self.internal_nodes:
@@ -245,20 +248,13 @@ class Graph(Element, Relational):
         **kwargs,
     ):
         """Display the graph using NetworkX and Matplotlib."""
+        g = self.to_networkx(**kwargs)
+        if _MATPLIB_AVAILABLE is not True:
+            raise _MATPLIB_AVAILABLE
 
-        try:
-            import matplotlib.pyplot as plt  # type: ignore
-            import networkx as nx  # type: ignore
-        except ImportError:
-            from lionagi.libs.package.imports import check_import
-
-            check_import("matplotlib")
-            check_import("networkx")
-
-            import matplotlib.pyplot as plt  # type: ignore
-            import networkx as nx  # type: ignore
+        import matplotlib.pyplot as plt  # type: ignore
+        import networkx as nx  # type: ignore
 
-        g = self.to_networkx(**kwargs)
         pos = nx.spring_layout(g)
         nx.draw(
             g,

lionagi/protocols/graph/node.py

@@ -4,10 +4,10 @@
 
 from __future__ import annotations
 
-import json
 from typing import Any
 
-from pydantic import field_validator
+import orjson
+from pydantic import BaseModel, field_serializer, field_validator
 from pydapter import Adaptable, AsyncAdaptable
 
 from lionagi._class_registry import LION_CLASS_REGISTRY
@@ -44,7 +44,7 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
             return None
         if isinstance(value, str):
             try:
-                loaded = json.loads(value)
+                loaded = orjson.loads(value)
                 if not isinstance(loaded, list):
                     raise ValueError
                 return [float(x) for x in loaded]
@@ -62,7 +62,8 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
     async def adapt_to_async(
         self, obj_key: str, many=False, **kwargs: Any
     ) -> Any:
-        kwargs["adapt_meth"] = "to_dict"
+        kwargs["adapt_meth"] = "as_jsonable"
+        kwargs["mode"] = "json"
         return await super().adapt_to_async(
             obj_key=obj_key, many=many, **kwargs
         )
@@ -84,7 +85,8 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         """
         Convert this Node to another format using a registered adapter.
         """
-        kwargs["adapt_meth"] = "to_dict"
+        kwargs["adapt_meth"] = "as_jsonable"
+        kwargs["mode"] = "json"
         return super().adapt_to(obj_key=obj_key, many=many, **kwargs)
 
     @classmethod
@@ -103,6 +105,22 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         kwargs["adapt_meth"] = "from_dict"
         return super().adapt_from(obj, obj_key=obj_key, many=many, **kwargs)
 
+    @field_serializer("content")
+    def _serialize_content(self, value: Any) -> Any:
+        if isinstance(value, Element):
+            return value.to_dict()
+        if isinstance(value, BaseModel):
+            return value.model_dump()
+        return value
+
+    @field_validator("content", mode="before")
+    def _validate_content(cls, value: Any) -> Any:
+        if isinstance(value, dict) and "lion_class" in value.get(
+            "metadata", {}
+        ):
+            return Element.from_dict(value)
+        return value
+
 
 if not _ADAPATER_REGISTERED:
     from pydapter.adapters import JsonAdapter, TomlAdapter

lionagi/protocols/messages/manager.py

@@ -392,79 +392,75 @@ class MessageManager(Manager):
 
     @property
     def last_response(self) -> AssistantResponse | None:
-        """
-        Retrieve the most recent `AssistantResponse`.
-        """
-        for mid in reversed(self.messages.progression):
-            if isinstance(self.messages[mid], AssistantResponse):
-                return self.messages[mid]
+        """Retrieve the most recent `AssistantResponse`."""
+        res = self.messages.filter_by_type(
+            item_type=AssistantResponse,
+            strict_type=True,
+            as_pile=False,
+            reverse=True,
+            num_items=1,
+        )
+        if len(res) == 1:
+            return res[0]
         return None
 
     @property
     def last_instruction(self) -> Instruction | None:
-        """
-        Retrieve the most recent `Instruction`.
-        """
-        for mid in reversed(self.messages.progression):
-            if isinstance(self.messages[mid], Instruction):
-                return self.messages[mid]
+        """Retrieve the most recent `Instruction`."""
+        res = self.messages.filter_by_type(
+            item_type=Instruction,
+            strict_type=True,
+            as_pile=False,
+            reverse=True,
+            num_items=1,
+        )
+        if len(res) == 1:
+            return res[0]
         return None
 
     @property
     def assistant_responses(self) -> Pile[AssistantResponse]:
         """All `AssistantResponse` messages in the manager."""
-        return Pile(
-            collections=[
-                self.messages[mid]
-                for mid in self.messages.progression
-                if isinstance(self.messages[mid], AssistantResponse)
-            ]
+        return self.messages.filter_by_type(
+            item_type=AssistantResponse,
+            strict_type=True,
+            as_pile=True,
         )
 
     @property
     def actions(self) -> Pile[ActionRequest | ActionResponse]:
         """All action messages in the manager."""
-        return Pile(
-            collections=[
-                self.messages[mid]
-                for mid in self.messages.progression
-                if isinstance(
-                    self.messages[mid], (ActionRequest, ActionResponse)
-                )
-            ]
+        return self.messages.filter_by_type(
+            item_type={ActionRequest, ActionResponse},
+            strict_type=True,
+            as_pile=True,
         )
 
     @property
     def action_requests(self) -> Pile[ActionRequest]:
         """All `ActionRequest` messages in the manager."""
-        return Pile(
-            collections=[
-                self.messages[mid]
-                for mid in self.messages.progression
-                if isinstance(self.messages[mid], ActionRequest)
-            ]
+        return self.messages.filter_by_type(
+            item_type=ActionRequest,
+            strict_type=True,
+            as_pile=True,
         )
 
     @property
     def action_responses(self) -> Pile[ActionResponse]:
         """All `ActionResponse` messages in the manager."""
-        return Pile(
-            collections=[
-                self.messages[mid]
-                for mid in self.messages.progression
-                if isinstance(self.messages[mid], ActionResponse)
-            ]
+        return self.messages.filter_by_type(
+            item_type=ActionResponse,
+            strict_type=True,
+            as_pile=True,
         )
 
     @property
     def instructions(self) -> Pile[Instruction]:
         """All `Instruction` messages in the manager."""
-        return Pile(
-            collections=[
-                self.messages[mid]
-                for mid in self.messages.progression
-                if isinstance(self.messages[mid], Instruction)
-            ]
+        return self.messages.filter_by_type(
+            item_type=Instruction,
+            strict_type=True,
+            as_pile=True,
         )
 
     def remove_last_instruction_tool_schemas(self) -> None:
@@ -481,7 +477,7 @@ class MessageManager(Manager):
         Example method to merge the content of recent ActionResponses
         into an instruction's context.
         """
-        for i in reversed(self.messages.progression):
+        for i in reversed(list(self.messages.progression)):
             if isinstance(self.messages[i], ActionResponse):
                 instruction.context.append(self.messages[i].content)
             else:

lionagi/protocols/messages/message.py

@@ -11,6 +11,8 @@ from typing import Any
 from jinja2 import Environment, FileSystemLoader, Template
 from pydantic import Field, PrivateAttr, field_serializer
 
+from lionagi import ln
+
 from .._concepts import Sendable
 from ..generic.element import Element, IDType
 from ..generic.log import Log
@@ -114,7 +116,7 @@ class RoledMessage(Node, Sendable):
             if isinstance(self.template, Template):
                 return self.template.render(**self.content)
         except Exception:
-            return json.dumps(self.content)
+            return ln.json_dumps(self.content)
 
     @classmethod
     def create(cls, **kwargs):