lionagi 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

lionagi/core/execute/structure_executor.py

@@ -288,7 +288,7 @@ class StructureExecutor(BaseExecutor, Graph):
             while self.pending_ins[key]:
                 mail: BaseMail = self.pending_ins[key].popleft()
                 try:
-                    if mail == "end":
+                    if mail.category == "end":
                         self.execute_stop = True
                         return
                     next_nodes = await self._handle_mail(mail)
@@ -312,3 +312,23 @@ class StructureExecutor(BaseExecutor, Graph):
         while not self.execute_stop:
             await self.forward()
             await AsyncUtil.sleep(refresh_time)
+
+    def to_excel(self, structure_name, dir="structure_storage"):
+        """
+        Exports the current structure to an Excel file using a specified structure name and directory.
+
+        This method utilizes the `to_excel` function from the `lionagi.integrations.storage.to_excel` module,
+        saving the current structure instance into an Excel file format. The Excel file will contain details
+        about nodes, edges, and other relevant data as separate sheets within the file.
+
+        Args:
+            structure_name (str): The name to assign to the structure within the Excel file. This name is
+                                  used as part of the file naming convention.
+            dir (str, optional): The directory where the Excel file will be saved. Defaults to "structure_storage".
+
+        Raises:
+            Exception: Propagates any exceptions raised by the `to_excel` function, which might occur during
+                       the file writing process or data formatting.
+        """
+        from lionagi.integrations.storage.to_excel import to_excel
+        to_excel(self, structure_name, dir)

lionagi/core/flow/monoflow/ReAct.py

@@ -145,7 +145,9 @@ class MonoReAct(MonoChat):
         if not self.branch.tool_manager.has_tools:
             raise ValueError("No tools found. You need to register tools.")
 
-        config = self.branch.tool_manager.parse_tool(tools=True, **kwargs)
+        if tools is None:
+            tools = True
+        config = self.branch.tool_manager.parse_tool(tools=tools, **kwargs)
         config["tool_parsed"] = True
         config["tool_choice"] = tool_choice
         return config

lionagi/core/flow/monoflow/followup.py

@@ -137,7 +137,9 @@ class MonoFollowup(MonoChat):
         if not self.branch.tool_manager.has_tools:
             raise ValueError("No tools found. You need to register tools.")
 
-        config = self.branch.tool_manager.parse_tool(tools=True, **kwargs)
+        if tools is None:
+            tools = True
+        config = self.branch.tool_manager.parse_tool(tools=tools, **kwargs)
         config["tool_parsed"] = True
         config["tool_choice"] = tool_choice
         return config

lionagi/core/generic/component.py

@@ -1,13 +1,12 @@
-"""This module provides base components used in lionagi"""
+"""base components in lionagi"""
 
 from abc import ABC
 from functools import singledispatchmethod
-from typing import Any, TypeVar
-
+from typing import Any, TypeVar, Type
 from pydantic import AliasChoices, BaseModel, Field, ValidationError
 from pandas import DataFrame, Series
 
-from lionagi.libs import SysUtil, func_call, convert, ParseUtil, nested
+from lionagi.libs import SysUtil, convert, ParseUtil, nested, func_call
 
 
 T = TypeVar("T")
@@ -28,24 +27,38 @@ class BaseComponent(BaseModel, ABC):
         validation_alias=AliasChoices("node_id", "ID", "id"),
         description="A 32-char unique hash identifier for the node.",
     )
-
     timestamp: str = Field(
         default_factory=lambda: SysUtil.get_timestamp(sep=None),
         description="The timestamp of when the node was created.",
     )
 
+    extra_fields: dict[str, Any] = Field(
+        default_factory=dict,
+        validation_alias=AliasChoices(
+            "extra", "additional_fields", "schema_extra", "extra_schema"
+        ),
+        description="Additional fields for the component.",
+    )
+
     class Config:
         """Model configuration settings."""
 
         extra = "allow"
         arbitrary_types_allowed = True
         populate_by_name = True
-        validate_assignment = True
-        validate_return = True
-        str_strip_whitespace = True
+
+    @property
+    def class_name(self) -> str:
+        """
+        Retrieve the name of the class.
+
+        Returns:
+            str: The name of the class.
+        """
+        return self._class_name()
 
     @classmethod
-    def class_name(cls) -> str:
+    def _class_name(cls) -> str:
         """
         Retrieve the name of the class.
 
@@ -54,6 +67,101 @@ class BaseComponent(BaseModel, ABC):
         """
         return cls.__name__
 
+    def to_json_str(self, *args, **kwargs) -> str:
+        """
+        Convert the component to a JSON string.
+
+        Returns:
+            str: The JSON string representation of the component.
+        """
+        dict_ = self.to_dict(*args, **kwargs)
+        return convert.to_str(dict_)
+
+    def to_dict(self, *args, **kwargs) -> dict[str, Any]:
+        """
+        Convert the component to a dictionary.
+
+        Returns:
+            dict[str, Any]: The dictionary representation of the component.
+        """
+        dict_ = self.model_dump(*args, by_alias=True, **kwargs)
+        for field_name in list(self.extra_fields.keys()):
+            if field_name not in dict_:
+                dict_[field_name] = getattr(self, field_name, None)
+        dict_.pop("extra_fields", None)
+        return dict_
+
+    def to_xml(self, *args, **kwargs) -> str:
+        """
+        Convert the component to an XML string.
+
+        Returns:
+            str: The XML string representation of the component.
+        """
+        import xml.etree.ElementTree as ET
+
+        root = ET.Element(self.__class__.__name__)
+
+        def convert(dict_obj: dict, parent: ET.Element) -> None:
+            for key, val in dict_obj.items():
+                if isinstance(val, dict):
+                    element = ET.SubElement(parent, key)
+                    convert(val, element)
+                else:
+                    element = ET.SubElement(parent, key)
+                    element.text = str(val)
+
+        convert(self.to_dict(*args, **kwargs), root)
+        return ET.tostring(root, encoding="unicode")
+
+    def to_pd_series(self, *args, pd_kwargs: dict | None = None, **kwargs) -> Series:
+        """
+        Convert the node to a Pandas Series.
+
+        Args:
+            pd_kwargs (dict | None): Additional keyword arguments for Pandas Series.
+
+        Returns:
+            Series: The Pandas Series representation of the node.
+        """
+        pd_kwargs = {} if pd_kwargs is None else pd_kwargs
+        dict_ = self.to_dict(*args, **kwargs)
+        return Series(dict_, **pd_kwargs)
+
+    def _add_field(
+        self,
+        field_name: str,
+        annotation: Any | Type | None = Any,
+        default: Any | None = None,
+        value: Any | None = None,
+        field: Any = None,
+        **kwargs,
+    ) -> None:
+        """
+        Add a field to the model after initialization.
+
+        Args:
+            field_name (str): The name of the field.
+            annotation (Any | Type | None): The type annotation for the field.
+            default (Any | None): The default value for the field.
+            value (Any | None): The initial value for the field.
+            field (Any): The Field object for the field.
+            **kwargs: Additional keyword arguments for the Field object.
+        """
+        field = field or Field(default=default, **kwargs)
+        self.extra_fields[field_name] = field
+        if annotation:
+            self.extra_fields[field_name].annotation = annotation
+
+        if not value and (a := self._get_field_attr(field_name, "default", None)):
+            value = a
+
+        self.__setattr__(field_name, value)
+
+    @property
+    def _all_fields(self):
+        return {**self.model_fields, **self.extra_fields}
+
     @property
     def _field_annotations(self) -> dict:
         """
@@ -62,21 +170,20 @@ class BaseComponent(BaseModel, ABC):
         Returns:
             dict: A dictionary mapping field names to their annotations.
         """
-        return self._get_field_annotation(list(self.model_fields.keys()))
 
-    def _get_field_attr(self, k: str, attr: str, default=False) -> Any:
+        return self._get_field_annotation(list(self._all_fields.keys()))
+
+    def _get_field_attr(self, k: str, attr: str, default: Any = False) -> Any:
         """
         Get the value of a field attribute.
 
         Args:
             k (str): The field name.
             attr (str): The attribute name.
-            default (Any): Default value to return if the attribute is not
-                found.
+            default (Any): Default value to return if the attribute is not found.
 
         Returns:
-            Any: The value of the field attribute, or the default value if not
-                found.
+            Any: The value of the field attribute, or the default value if not found.
 
         Raises:
             ValueError: If the field does not have the specified attribute.
@@ -84,8 +191,9 @@ class BaseComponent(BaseModel, ABC):
         try:
             if not self._field_has_attr(k, attr):
                 raise ValueError(f"field {k} has no attribute {attr}")
-            field = self.model_fields[k]
-            a = getattr(field, attr)
+
+            field = self._all_fields[k]
+            a = getattr(field, attr, None)
             if not a:
                 try:
                     a = field.json_schema_extra[attr]
@@ -99,7 +207,7 @@ class BaseComponent(BaseModel, ABC):
             raise e
 
     @singledispatchmethod
-    def _get_field_annotation(self, field_name: str) -> Any:
+    def _get_field_annotation(self, field_name: Any) -> Any:
         """
         Get the annotation for a field.
 
@@ -112,7 +220,7 @@ class BaseComponent(BaseModel, ABC):
         raise TypeError(f"Unsupported type {type(field_name)}")
 
     @_get_field_annotation.register(str)
-    def _(self, field_name) -> dict[str, Any]:
+    def _(self, field_name: str) -> dict[str, Any]:
         """
         Get the annotation for a field as a dictionary.
 
@@ -120,10 +228,9 @@ class BaseComponent(BaseModel, ABC):
             field_name (str): The name of the field.
 
         Returns:
-            dict[str, Any]: A dictionary mapping the field name to its
-                annotation.
+            dict[str, Any]: A dictionary mapping the field name to its annotation.
         """
-        dict_ = {field_name: self.model_fields[field_name].annotation}
+        dict_ = {field_name: self._all_fields[field_name].annotation}
         for k, v in dict_.items():
             if "|" in str(v):
                 v = str(v)
@@ -134,37 +241,20 @@ class BaseComponent(BaseModel, ABC):
         return dict_
 
     @_get_field_annotation.register(list)
-    def _(self, field_name) -> dict[str, Any]:
-        """
-        Get the annotations for multiple fields as a dictionary.
-
-        Args:
-            field_name (list): A list or tuple of field names.
-
-        Returns:
-            dict[str, Any]: A dictionary mapping field names to their
-                annotations.
-        """
-        dict_ = {}
-        for i in field_name:
-            dict_.update(self._get_field_annotation(i))
-        return dict_
-
     @_get_field_annotation.register(tuple)
-    def _(self, field_name) -> dict[str, Any]:
+    def _(self, field_names: list | tuple) -> dict[str, Any]:
         """
         Get the annotations for multiple fields as a dictionary.
 
         Args:
-            field_name (tuple): A list or tuple of field names.
+            field_names (list | tuple): A list or tuple of field names.
 
         Returns:
-            dict[str, Any]: A dictionary mapping field names to their
-                annotations.
+            dict[str, Any]: A dictionary mapping field names to their annotations.
         """
         dict_ = {}
-        for i in field_name:
-            dict_.update(self._get_field_annotation(i))
+        for field_name in field_names:
+            dict_.update(self._get_field_annotation(field_name))
         return dict_
 
     def _field_has_attr(self, k: str, attr: str) -> bool:
@@ -178,7 +268,7 @@ class BaseComponent(BaseModel, ABC):
         Returns:
             bool: True if the field has the attribute, False otherwise.
         """
-        field = self.model_fields.get(k, None)
+        field = self._all_fields.get(k, None)
         if field is None:
             raise ValueError(f"Field {k} not found in model fields.")
 
@@ -186,65 +276,16 @@ class BaseComponent(BaseModel, ABC):
         if not a:
             try:
                 a = (
-                    self.model_fields[k].json_schema_extra[attr] is not None
-                    and attr in self.model_fields[k].json_schema_extra
+                    self._all_fields[k].json_schema_extra[attr] is not None
+                    and attr in self._all_fields[k].json_schema_extra
                 )
                 return a if isinstance(a, bool) else False
             except Exception:
                 return False
         return a
 
-    def to_json_str(self, *args, **kwargs) -> str:
-        """
-        Convert the component to a JSON string.
-
-        Returns:
-            str: The JSON string representation of the component.
-        """
-        return self.model_dump_json(*args, by_alias=True, **kwargs)
-
-    def to_dict(self, *args, **kwargs) -> dict[str, Any]:
-        """
-        Convert the component to a dictionary.
-
-        Returns:
-            dict[str, Any]: The dictionary representation of the component.
-        """
-        return self.model_dump(*args, by_alias=True, **kwargs)
-
-    def to_xml(self) -> str:
-        """
-        Convert the component to an XML string.
-
-        Returns:
-            str: The XML string representation of the component.
-        """
-        import xml.etree.ElementTree as ET
-
-        root = ET.Element(self.__class__.__name__)
-
-        def convert(dict_obj, parent):
-            for key, val in dict_obj.items():
-                if isinstance(val, dict):
-                    element = ET.SubElement(parent, key)
-                    convert(val, element)
-                else:
-                    element = ET.SubElement(parent, key)
-                    element.text = str(val)
-
-        convert(self.to_dict(), root)
-        return ET.tostring(root, encoding="unicode")
-
-    def to_pd_series(self, *args, pd_kwargs: dict | None = None, **kwargs) -> Series:
-        """
-        Convert the node to a Pandas Series.
-
-        Returns:
-            Series: The Pandas Series representation of the node.
-        """
-        pd_kwargs = {} if pd_kwargs is None else pd_kwargs
-        dict_ = self.to_dict(*args, **kwargs)
-        return Series(dict_, **pd_kwargs)
+    def __str__(self):
+        return f"{self.__class__.__name__}({self.to_json_str()})"
 
 
 class BaseNode(BaseComponent):
@@ -264,7 +305,7 @@ class BaseNode(BaseComponent):
 
     metadata: dict[str, Any] = Field(
         default_factory=dict,
-        alias="meta",
+        validation_alias="meta",
         description="Additional metadata for the node.",
     )
 
@@ -276,20 +317,36 @@ class BaseNode(BaseComponent):
 
         Args:
             obj (Any): The object to create the node from.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
 
         Raises:
             NotImplementedError: If the object type is not supported.
         """
+        if not isinstance(obj, (dict, str, list, Series, DataFrame, BaseModel)):
+            type_ = str(type(obj))
+            if "llama_index" in type_:
+                return cls.from_obj(obj.to_dict())
+            elif "langchain" in type_:
+                langchain_json = obj.to_json()
+                langchain_dict = {
+                    "lc_id": langchain_json["id"],
+                    **langchain_json["kwargs"],
+                }
+                return cls.from_obj(langchain_dict)
+
         raise NotImplementedError(f"Unsupported type: {type(obj)}")
 
     @from_obj.register(dict)
     @classmethod
-    def _from_dict(cls, obj, *args, **kwargs) -> T:
+    def _from_dict(cls, obj: dict, *args, **kwargs) -> T:
         """
         Create a node instance from a dictionary.
 
         Args:
             obj (dict): The dictionary to create the node from.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
 
         Returns:
             T: The created node instance.
@@ -298,13 +355,15 @@ class BaseNode(BaseComponent):
 
     @from_obj.register(str)
     @classmethod
-    def _from_str(cls, obj, *args, fuzzy_parse=False, **kwargs) -> T:
+    def _from_str(cls, obj: str, *args, fuzzy_parse: bool = False, **kwargs) -> T:
         """
         Create a node instance from a JSON string.
 
         Args:
             obj (str): The JSON string to create the node from.
+            *args: Additional positional arguments.
             fuzzy_parse (bool): Whether to perform fuzzy parsing.
+            **kwargs: Additional keyword arguments.
 
         Returns:
             T: The created node instance.
@@ -317,12 +376,14 @@ class BaseNode(BaseComponent):
 
     @from_obj.register(list)
     @classmethod
-    def _from_list(cls, obj, *args, **kwargs) -> list[T]:
+    def _from_list(cls, obj: list, *args, **kwargs) -> list[T]:
         """
         Create a list of node instances from a list of objects.
 
         Args:
             obj (list): The list of objects to create nodes from.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
 
         Returns:
             list[T]: The list of created node instances.
@@ -331,37 +392,51 @@ class BaseNode(BaseComponent):
 
     @from_obj.register(Series)
     @classmethod
-    def _from_pd_series(cls, obj, *args, pd_kwargs=None, **kwargs) -> T:
+    def _from_pd_series(
+        cls, obj: Series, *args, pd_kwargs: dict | None = None, **kwargs
+    ) -> T:
         """
         Create a node instance from a Pandas Series.
 
         Args:
             obj (Series): The Pandas Series to create the node from.
+            *args: Additional positional arguments.
+            pd_kwargs (dict | None): Additional keyword arguments for Pandas Series.
+            **kwargs: Additional keyword arguments.
 
         Returns:
             T: The created node instance.
         """
-        if pd_kwargs is None:
-            pd_kwargs = {}
+        pd_kwargs = pd_kwargs or {}
         return cls.from_obj(obj.to_dict(**pd_kwargs), *args, **kwargs)
 
     @from_obj.register(DataFrame)
     @classmethod
-    def _from_pd_dataframe(cls, obj, *args, pd_kwargs=None, **kwargs) -> list[T]:
+    def _from_pd_dataframe(
+        cls, obj: DataFrame, *args, pd_kwargs: dict | None = None, **kwargs
+    ) -> list[T]:
         """
         Create a list of node instances from a Pandas DataFrame.
 
         Args:
             obj (DataFrame): The Pandas DataFrame to create nodes from.
+            *args: Additional positional arguments.
+            pd_kwargs (dict | None): Additional keyword arguments for Pandas DataFrame.
+            **kwargs: Additional keyword arguments.
 
         Returns:
             list[T]: The list of created node instances.
         """
         if pd_kwargs is None:
             pd_kwargs = {}
-        return [
-            cls.from_obj(row, *args, **pd_kwargs, **kwargs) for _, row in obj.iterrows()
-        ]
+
+        _objs = []
+        for index, row in obj.iterrows():
+            _obj = cls.from_obj(row, *args, **pd_kwargs, **kwargs)
+            _obj.metadata["df_index"] = index
+            _objs.append(_obj)
+
+        return _objs
 
     @from_obj.register(BaseModel)
     @classmethod
@@ -375,27 +450,29 @@ class BaseNode(BaseComponent):
         Returns:
             T: The created node instance.
         """
-        if pydantic_kwargs is None:
-            pydantic_kwargs = {"by_alias": True}
-
-        config_ = {}
+        pydantic_kwargs = pydantic_kwargs or {"by_alias": True}
         try:
-            config_ = obj.model_dump(**pydantic_kwargs)
-        except:
-            config_ = obj.dict(**pydantic_kwargs)
+            config_ = {}
+            try:
+                config_ = obj.model_dump(**pydantic_kwargs)
+            except:
+                config_ = obj.to_dict(**pydantic_kwargs)
+            else:
+                config_ = obj.dict(**pydantic_kwargs)
+        except Exception as e:
+            raise ValueError(f"Invalid Pydantic model for deserialization: {e}") from e
 
         return cls.from_obj(config_ | kwargs)
 
     def meta_get(
-        self, key: str, indices: list[str | int] = None, default: Any = None
+        self, key: str, indices: list[str | int] | None = None, default: Any = None
     ) -> Any:
         """
         Get a value from the metadata dictionary.
 
         Args:
             key (str): The key to retrieve the value for.
-            indices (list[str | int]): Optional list of indices for nested
-                retrieval.
+            indices (list[str | int] | None): Optional list of indices for nested retrieval.
             default (Any): The default value to return if the key is not found.
 
         Returns:
@@ -452,4 +529,4 @@ class BaseNode(BaseComponent):
         """
         self.metadata = nested.nmerge(
             [self.metadata, additional_metadata], overwrite=overwrite, **kwargs
-        )
+        )

lionagi/core/generic/condition.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from enum import Enum
+from typing import Callable
 from pydantic import BaseModel, Field
 
 
@@ -14,6 +15,7 @@ class ConditionSource(str, Enum):
 
     STRUCTURE = "structure"
     EXECUTABLE = "executable"
+    RULE = "rule"
 
 
 class Condition(BaseModel, ABC):