lionagi 0.0.305__py3-none-any.whl → 0.0.307__py3-none-any.whl

lionagi/core/messages/schema.py

@@ -1,11 +1,10 @@
 from enum import Enum
 
-from lionagi.libs import ln_nested as nested
-from lionagi.libs import ln_convert as convert
+from lionagi.libs import nested, convert
+from ..schema import DataNode
 
-from lionagi.core.schema.data_node import DataNode
+_message_fields = ["node_id", "timestamp", "role", "sender", "recipient", "content"]
 
-_message_fields = ["node_id", "timestamp", "role", "sender", "content"]
 
 # ToDo: actually implement the new message classes
 
@@ -99,13 +98,14 @@ class BaseMessage(DataNode):
     Represents a message in a chatbot-like system, inheriting from BaseNode.
 
     Attributes:
-        role (str | None): The role of the entity sending the message, e.g., 'user', 'system'.
-        sender (str | None): The identifier of the sender of the message.
-        content (Any): The actual content of the message.
+            role (str | None): The role of the entity sending the message, e.g., 'user', 'system'.
+            sender (str | None): The identifier of the sender of the message.
+            content (Any): The actual content of the message.
     """
 
     role: str | None = None
     sender: str | None = None
+    recipient: str | None = None
 
     @property
     def msg(self) -> dict:
@@ -113,7 +113,7 @@ class BaseMessage(DataNode):
         Constructs and returns a dictionary representation of the message.
 
         Returns:
-            A dictionary representation of the message with 'role' and 'content' keys.
+                A dictionary representation of the message with 'role' and 'content' keys.
         """
         return self._to_message()
 
@@ -123,7 +123,7 @@ class BaseMessage(DataNode):
         Gets the 'content' field of the message.
 
         Returns:
-            The 'content' part of the message.
+                The 'content' part of the message.
         """
         return self.msg["content"]
 
@@ -132,14 +132,13 @@ class BaseMessage(DataNode):
         Constructs and returns a dictionary representation of the message.
 
         Returns:
-            dict: A dictionary representation of the message with 'role' and 'content' keys.
+                dict: A dictionary representation of the message with 'role' and 'content' keys.
         """
-        out = {"role": self.role, "content": convert.to_str(self.content)}
-        return out
+        return {"role": self.role, "content": convert.to_str(self.content)}
 
     def __str__(self):
         content_preview = (
-            (str(self.content)[:75] + "...")
+            f"{str(self.content)[:75]}..."
             if self.content and len(self.content) > 75
             else str(self.content)
         )
@@ -160,9 +159,13 @@ class Instruction(BaseMessage):
         context=None,
         sender: str | None = None,
         output_fields=None,
-    ):
+        recipient=None,
+    ):  # sourcery skip: avoid-builtin-shadow
         super().__init__(
-            role="user", sender=sender or "user", content={"instruction": instruction}
+            role="user",
+            sender=sender or "user",
+            content={"instruction": instruction},
+            recipient=recipient or "assistant",
         )
         if context:
             self.content.update({"context": context})
@@ -176,6 +179,10 @@ class Instruction(BaseMessage):
             """
             self.content.update({"response_format": format})
 
+    @property
+    def instruct(self):
+        return self.content["instruction"]
+
 
 class System(BaseMessage):
     """
@@ -184,11 +191,20 @@ class System(BaseMessage):
     Designed for messages containing system information, this class sets the message role to 'system'.
     """
 
-    def __init__(self, system: dict | list | str, sender: str | None = None):
+    def __init__(
+        self, system: dict | list | str, sender: str | None = None, recipient=None
+    ):
         super().__init__(
-            role="system", sender=sender or "system", content={"system_info": system}
+            role="system",
+            sender=sender or "system",
+            content={"system_info": system},
+            recipient=recipient or "assistant",
         )
 
+    @property
+    def system_info(self):
+        return self.content["system_info"]
+
 
 class Response(BaseMessage):
     """
@@ -199,7 +215,9 @@ class Response(BaseMessage):
 
     """
 
-    def __init__(self, response: dict | list | str, sender: str | None = None) -> None:
+    def __init__(
+        self, response: dict | list | str, sender: str | None = None, recipient=None
+    ) -> None:
         content_key = ""
         try:
             response = response["message"]
@@ -207,6 +225,7 @@ class Response(BaseMessage):
                 content_ = self._handle_action_request(response)
                 sender = sender or "action_request"
                 content_key = content_key or "action_request"
+                recipient = recipient or "action"
 
             else:
                 try:
@@ -214,32 +233,44 @@ class Response(BaseMessage):
                         content_ = convert.to_dict(response["content"])["tool_uses"]
                         content_key = content_key or "action_request"
                         sender = sender or "action_request"
+                        recipient = recipient or "action"
+
                     elif "response" in convert.to_dict(response["content"]):
                         sender = sender or "assistant"
                         content_key = content_key or "response"
                         content_ = convert.to_dict(response["content"])["response"]
+                        recipient = recipient or "user"
+
                     elif "action_request" in convert.to_dict(response["content"]):
                         sender = sender or "action_request"
                         content_key = content_key or "action_request"
                         content_ = convert.to_dict(response["content"])[
                             "action_request"
                         ]
+                        recipient = recipient or "action"
+
                     else:
                         content_ = response["content"]
                         content_key = content_key or "response"
                         sender = sender or "assistant"
-                except:
+                        recipient = recipient or "user"
+                except Exception:
                     content_ = response["content"]
                     content_key = content_key or "response"
                     sender = sender or "assistant"
+                    recipient = recipient or "user"
 
-        except:
+        except Exception:
             sender = sender or "action_response"
             content_ = response
             content_key = content_key or "action_response"
+            recipient = recipient or "assistant"
 
         super().__init__(
-            role="assistant", sender=sender, content={content_key: content_}
+            role="assistant",
+            sender=sender,
+            content={content_key: content_},
+            recipient=recipient,
         )
 
     @staticmethod
@@ -248,13 +279,13 @@ class Response(BaseMessage):
         Processes an action request response and extracts relevant information.
 
         Args:
-            response (dict): The response dictionary containing tool calls and other information.
+                response (dict): The response dictionary containing tool calls and other information.
 
         Returns:
-            list: A list of dictionaries, each representing a function call with action and arguments.
+                list: A list of dictionaries, each representing a function call with action and arguments.
 
         Raises:
-            ValueError: If the response does not conform to the expected format for action requests.
+                ValueError: If the response does not conform to the expected format for action requests.
         """
         try:
             tool_count = 0
@@ -267,7 +298,7 @@ class Response(BaseMessage):
                     _path2 = ["tool_calls", tool_count, "function", "arguments"]
 
                     func_content = {
-                        "action": ("action_" + nested.nget(response, _path1)),
+                        "action": f"action_{nested.nget(response, _path1)}",
                         "arguments": nested.nget(response, _path2),
                     }
                     func_list.append(func_content)

lionagi/core/schema/__init__.py

@@ -1,17 +1,19 @@
-from .base_node import BaseNode, BaseRelatableNode, Tool
-from .data_logger import DataLogger, DLog
+from .base_node import BaseNode, BaseRelatableNode, Tool, TOOL_TYPE
 from .data_node import DataNode
+from .data_logger import DLog, DataLogger
 from .structure import Relationship, Graph, Structure
-
+from .action_node import ActionNode
 
 __all__ = [
-    "DLog",
     "BaseNode",
     "BaseRelatableNode",
     "Tool",
-    "DataLogger",
     "DataNode",
+    "DLog",
+    "DataLogger",
     "Relationship",
     "Graph",
     "Structure",
+    "ActionNode",
+    "TOOL_TYPE",
 ]

lionagi/core/schema/action_node.py

@@ -0,0 +1,29 @@
+from enum import Enum
+
+from .base_node import BaseNode
+
+
+class ActionSelection(BaseNode):
+
+    def __init__(self, action: str = "chat", action_kwargs=None):
+        if action_kwargs is None:
+            action_kwargs = {}
+        super().__init__()
+        self.action = action
+        self.action_kwargs = action_kwargs
+
+
+class ActionNode(BaseNode):
+
+    def __init__(
+        self, instruction, action: str = "chat", tools=None, action_kwargs=None
+    ):
+        if tools is None:
+            tools = []
+        if action_kwargs is None:
+            action_kwargs = {}
+        super().__init__()
+        self.instruction = instruction
+        self.action = action
+        self.tools = tools
+        self.action_kwargs = action_kwargs

lionagi/core/schema/base_mixin.py

@@ -5,10 +5,7 @@ from typing import Any, TypeVar, Type, Callable
 import pandas as pd
 from pydantic import BaseModel, ValidationError
 
-import lionagi.libs.ln_nested as nested
-import lionagi.libs.ln_convert as convert
-from lionagi.libs.ln_parse import ParseUtil
-from lionagi.libs.sys_util import SysUtil
+from lionagi.libs import nested, convert, ParseUtil, SysUtil
 
 T = TypeVar("T")  # Generic type for return type of from_obj method
 
@@ -24,12 +21,12 @@ class BaseToObjectMixin(ABC, BaseModel):
         string. It supports passing arbitrary arguments to the underlying `model_dump_json` method.
 
         Args:
-            *args: Variable-length argument list to be passed to `model_dump_json`.
-            **kwargs: Arbitrary keyword arguments, with `by_alias=True` set by default to use
-                      model field aliases in the output JSON, if any.
+                *args: Variable-length argument list to be passed to `model_dump_json`.
+                **kwargs: Arbitrary keyword arguments, with `by_alias=True` set by default to use
+                                  model field aliases in the output JSON, if any.
 
         Returns:
-            str: A JSON string representation of the model instance.
+                str: A JSON string representation of the model instance.
         """
         return self.model_dump_json(*args, by_alias=True, **kwargs)
 
@@ -42,12 +39,12 @@ class BaseToObjectMixin(ABC, BaseModel):
         aliases instead of the original field names.
 
         Args:
-            *args: Variable-length argument list for the `model_dump` method.
-            **kwargs: Arbitrary keyword arguments. By default, `by_alias=True` is applied, indicating
-                      that field aliases should be used as keys in the resulting dictionary.
+                *args: Variable-length argument list for the `model_dump` method.
+                **kwargs: Arbitrary keyword arguments. By default, `by_alias=True` is applied, indicating
+                                  that field aliases should be used as keys in the resulting dictionary.
 
         Returns:
-            dict[str, Any]: The dictionary representation of the model instance.
+                dict[str, Any]: The dictionary representation of the model instance.
         """
         return self.model_dump(*args, by_alias=True, **kwargs)
 
@@ -60,7 +57,7 @@ class BaseToObjectMixin(ABC, BaseModel):
         The root element of the XML tree is named after the class of the model instance.
 
         Returns:
-            str: An XML string representation of the model instance.
+                str: An XML string representation of the model instance.
         """
 
         import xml.etree.ElementTree as ET
@@ -88,15 +85,15 @@ class BaseToObjectMixin(ABC, BaseModel):
         customize the Series creation through `pd_kwargs`.
 
         Args:
-            *args: Variable-length argument list for the `to_dict` method.
-            pd_kwargs (dict | None): Optional dictionary of keyword arguments to pass to the pandas
-                                     Series constructor. Defaults to None, in which case an empty
-                                     dictionary is used.
-            **kwargs: Arbitrary keyword arguments for the `to_dict` method, influencing the dictionary
-                      representation used for Series creation.
+                *args: Variable-length argument list for the `to_dict` method.
+                pd_kwargs (dict | None): Optional dictionary of keyword arguments to pass to the pandas
+                                                                 Series constructor. Defaults to None, in which case an empty
+                                                                 dictionary is used.
+                **kwargs: Arbitrary keyword arguments for the `to_dict` method, influencing the dictionary
+                                  representation used for Series creation.
 
         Returns:
-            pd.Series: A pandas Series representation of the model instance.
+                pd.Series: A pandas Series representation of the model instance.
         """
         pd_kwargs = {} if pd_kwargs is None else pd_kwargs
         dict_ = self.to_dict(*args, **kwargs)
@@ -118,15 +115,11 @@ class BaseFromObjectMixin(ABC, BaseModel):
     @from_obj.register(str)
     @classmethod
     def _from_str(cls, obj: str, *args, fuzzy_parse=False, **kwargs) -> T:
-        if fuzzy_parse:
-            obj = ParseUtil.fuzzy_parse_json(obj)
-        else:
-            obj = convert.to_dict(obj)
-
+        obj = ParseUtil.fuzzy_parse_json(obj) if fuzzy_parse else convert.to_dict(obj)
         try:
             return cls.from_obj(obj, *args, **kwargs)
         except ValidationError as e:
-            raise ValueError(f"Invalid JSON for deserialization: {e}")
+            raise ValueError(f"Invalid JSON for deserialization: {e}") from e
 
     @from_obj.register(list)
     @classmethod
@@ -135,23 +128,27 @@ class BaseFromObjectMixin(ABC, BaseModel):
 
     @from_obj.register(pd.Series)
     @classmethod
-    def _from_pd_series(cls, obj: pd.Series, *args, pd_kwargs={}, **kwargs) -> T:
+    def _from_pd_series(cls, obj: pd.Series, *args, pd_kwargs=None, **kwargs) -> T:
+        if pd_kwargs is None:
+            pd_kwargs = {}
         return cls.from_obj(obj.to_dict(**pd_kwargs), *args, **kwargs)
 
     @from_obj.register(pd.DataFrame)
     @classmethod
     def _from_pd_dataframe(
-        cls, obj: pd.DataFrame, *args, pd_kwargs={}, **kwargs
+        cls, obj: pd.DataFrame, *args, pd_kwargs=None, **kwargs
     ) -> list[T]:
+        if pd_kwargs is None:
+            pd_kwargs = {}
         return [
             cls.from_obj(row, *args, **pd_kwargs, **kwargs) for _, row in obj.iterrows()
         ]
 
     @from_obj.register(BaseModel)
     @classmethod
-    def _from_base_model(
-        cls, obj: BaseModel, pydantic_kwargs={"by_alias": True}, **kwargs
-    ) -> T:
+    def _from_base_model(cls, obj: BaseModel, pydantic_kwargs=None, **kwargs) -> T:
+        if pydantic_kwargs is None:
+            pydantic_kwargs = {"by_alias": True}
         config_ = {**obj.model_dump(**pydantic_kwargs), **kwargs}
         return cls.from_obj(**config_)
 
@@ -163,11 +160,11 @@ class BaseMetaManageMixin(ABC, BaseModel):
         Retrieves a list of metadata keys.
 
         Args:
-            flattened (bool): If True, returns keys from a flattened metadata structure.
-            **kwargs: Additional keyword arguments passed to the flattening function.
+                flattened (bool): If True, returns keys from a flattened metadata structure.
+                **kwargs: Additional keyword arguments passed to the flattening function.
 
         Returns:
-            list[str]: List of metadata keys.
+                list[str]: List of metadata keys.
         """
         if flattened:
             return nested.get_flattened_keys(self.metadata, **kwargs)
@@ -178,12 +175,12 @@ class BaseMetaManageMixin(ABC, BaseModel):
         Checks if a specified key exists in the metadata.
 
         Args:
-            key (str): The key to check.
-            flattened (bool): If True, checks within a flattened metadata structure.
-            **kwargs: Additional keyword arguments for flattening.
+                key (str): The key to check.
+                flattened (bool): If True, checks within a flattened metadata structure.
+                **kwargs: Additional keyword arguments for flattening.
 
         Returns:
-            bool: True if key exists, False otherwise.
+                bool: True if key exists, False otherwise.
         """
         if flattened:
             return key in nested.get_flattened_keys(self.metadata, **kwargs)
@@ -196,12 +193,12 @@ class BaseMetaManageMixin(ABC, BaseModel):
         Retrieves the value associated with a given key from the metadata.
 
         Args:
-            key (str): The key for the desired value.
-            indices: Optional indices for nested retrieval.
-            default (Any): The default value to return if the key is not found.
+                key (str): The key for the desired value.
+                indices: Optional indices for nested retrieval.
+                default (Any): The default value to return if the key is not found.
 
         Returns:
-            Any: The value associated with the key or the default value.
+                Any: The value associated with the key or the default value.
         """
         if indices:
             return nested.nget(self.metadata, key, indices, default)
@@ -212,11 +209,11 @@ class BaseMetaManageMixin(ABC, BaseModel):
         Renames a key in the metadata.
 
         Args:
-            old_key (str): The current key name.
-            new_key (str): The new key name.
+                old_key (str): The current key name.
+                new_key (str): The new key name.
 
         Returns:
-            bool: True if the key was changed, False otherwise.
+                bool: True if the key was changed, False otherwise.
         """
         if old_key in self.metadata:
             SysUtil.change_dict_key(self.metadata, old_key, new_key)
@@ -228,12 +225,12 @@ class BaseMetaManageMixin(ABC, BaseModel):
         Inserts a value into the metadata at specified indices.
 
         Args:
-            indices (str | list): The indices where the value should be inserted.
-            value (Any): The value to insert.
-            **kwargs: Additional keyword arguments.
+                indices (str | list): The indices where the value should be inserted.
+                value (Any): The value to insert.
+                **kwargs: Additional keyword arguments.
 
         Returns:
-            bool: True if the insertion was successful, False otherwise.
+                bool: True if the insertion was successful, False otherwise.
         """
         return nested.ninsert(self.metadata, indices, value, **kwargs)
 
@@ -243,11 +240,11 @@ class BaseMetaManageMixin(ABC, BaseModel):
         Removes a key from the metadata and returns its value.
 
         Args:
-            key (str): The key to remove.
-            default (Any): The default value to return if the key is not found.
+                key (str): The key to remove.
+                default (Any): The default value to return if the key is not found.
 
         Returns:
-            Any: The value of the removed key or the default value.
+                Any: The value of the removed key or the default value.
         """
         return self.metadata.pop(key, default)
 
@@ -258,12 +255,12 @@ class BaseMetaManageMixin(ABC, BaseModel):
         Merges additional metadata into the existing metadata.
 
         Args:
-            additional_metadata (dict[str, Any]): The metadata to merge in.
-            overwrite (bool): If True, existing keys will be overwritten by those in additional_metadata.
-            **kwargs: Additional keyword arguments for the merge.
+                additional_metadata (dict[str, Any]): The metadata to merge in.
+                overwrite (bool): If True, existing keys will be overwritten by those in additional_metadata.
+                **kwargs: Additional keyword arguments for the merge.
 
         Returns:
-            None
+                None
         """
         nested.nmerge(
             [self.metadata, additional_metadata], overwrite=overwrite, **kwargs
@@ -278,7 +275,7 @@ class BaseMetaManageMixin(ABC, BaseModel):
         Clears all metadata.
 
         Returns:
-            None
+                None
         """
         self.metadata.clear()
 
@@ -287,10 +284,10 @@ class BaseMetaManageMixin(ABC, BaseModel):
         Filters the metadata based on a condition.
 
         Args:
-            condition (Callable[[Any, Any], bool]): The condition function to apply.
+                condition (Callable[[Any, Any], bool]): The condition function to apply.
 
         Returns:
-            dict[str, Any]: The filtered metadata.
+                dict[str, Any]: The filtered metadata.
         """
         return nested.nfilter(self.metadata, condition)