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

lionagi/core/schema/base_node.py

@@ -5,14 +5,11 @@ Module for base component model definition using Pydantic.
 from abc import ABC
 from typing import Any, TypeVar
 
-import lionagi.integrations.bridge.pydantic_.base_model as pyd
-from lionagi.libs.sys_util import SysUtil
-
-from lionagi.libs import ln_convert as convert
+from pydantic import Field, field_serializer, AliasChoices
+from lionagi.libs import SysUtil, convert
 
 from .base_mixin import BaseComponentMixin
 
-
 T = TypeVar("T", bound="BaseComponent")
 
 
@@ -23,16 +20,16 @@ class BaseComponent(BaseComponentMixin, ABC):
     and validating metadata keys and values.
 
     Attributes:
-        id_ (str): Unique identifier, defaulted using SysUtil.create_id.
-        timestamp (str | None): Timestamp of creation or modification.
-        metadata (dict[str, Any]): Metadata associated with the component.
+            id_ (str): Unique identifier, defaulted using SysUtil.create_id.
+            timestamp (str | None): Timestamp of creation or modification.
+            metadata (dict[str, Any]): Metadata associated with the component.
     """
 
-    id_: str = pyd.ln_Field(default_factory=SysUtil.create_id, alias="node_id")
-    timestamp: str | None = pyd.ln_Field(default_factory=SysUtil.get_timestamp)
-    metadata: dict[str, Any] = pyd.ln_Field(default_factory=dict, alias="meta")
+    id_: str = Field(default_factory=SysUtil.create_id, alias="node_id")
+    timestamp: str | None = Field(default_factory=SysUtil.get_timestamp)
+    metadata: dict[str, Any] = Field(default_factory=dict, alias="meta")
 
-    class Config:
+    class ConfigDict:
         """Model configuration settings."""
 
         extra = "allow"
@@ -46,11 +43,11 @@ class BaseComponent(BaseComponentMixin, ABC):
         Creates a deep copy of the instance, with an option to update specific fields.
 
         Args:
-            *args: Variable length argument list for additional options.
-            **kwargs: Arbitrary keyword arguments specifying updates to the instance.
+                *args: Variable length argument list for additional options.
+                **kwargs: Arbitrary keyword arguments specifying updates to the instance.
 
         Returns:
-            BaseComponent: A new instance of BaseComponent as a deep copy of the original, with updates applied.
+                BaseComponent: A new instance of BaseComponent as a deep copy of the original, with updates applied.
         """
         return self.model_copy(*args, **kwargs)
 
@@ -64,15 +61,15 @@ class BaseNode(BaseComponent):
     extending BaseComponent with content handling capabilities.
 
     Attributes:
-        content: The content of the node, which can be a string, a dictionary with any structure,
-            None, or any other type. It is flexible to accommodate various types of content.
-            This attribute also supports aliasing through validation_alias for compatibility with
-            different naming conventions like "text", "page_content", or "chunk_content".
+            content: The content of the node, which can be a string, a dictionary with any structure,
+                    None, or any other type. It is flexible to accommodate various types of content.
+                    This attribute also supports aliasing through validation_alias for compatibility with
+                    different naming conventions like "text", "page_content", or "chunk_content".
     """
 
-    content: str | dict[str, Any] | None | Any = pyd.ln_Field(
+    content: str | dict[str, Any] | None | Any = Field(
         default=None,
-        validation_alias=pyd.ln_AliasChoices("text", "page_content", "chunk_content"),
+        validation_alias=AliasChoices("text", "page_content", "chunk_content"),
     )
 
     @property
@@ -81,8 +78,8 @@ class BaseNode(BaseComponent):
         Attempts to serialize the node's content to a string.
 
         Returns:
-            str: The serialized content string. If serialization fails, returns "null" and
-                logs an error message indicating the content is not serializable.
+                str: The serialized content string. If serialization fails, returns "null" and
+                        logs an error message indicating the content is not serializable.
         """
         try:
             return convert.to_str(self.content)
@@ -98,17 +95,17 @@ class BaseNode(BaseComponent):
         metadata preview, and optionally the timestamp if present.
 
         Returns:
-            str: A string representation of the instance.
+                str: A string representation of the instance.
         """
         timestamp = f" ({self.timestamp})" if self.timestamp else ""
         if self.content:
             content_preview = (
-                self.content[:50] + "..." if len(self.content) > 50 else self.content
+                f"{self.content[:50]}..." if len(self.content) > 50 else self.content
             )
         else:
             content_preview = ""
         meta_preview = (
-            str(self.metadata)[:50] + "..."
+            f"{str(self.metadata)[:50]}..."
             if len(str(self.metadata)) > 50
             else str(self.metadata)
         )
@@ -123,11 +120,11 @@ class BaseRelatableNode(BaseNode):
     Extends BaseNode with functionality to manage relationships with other nodes.
 
     Attributes:
-        related_nodes: A list of identifiers (str) for nodes that are related to this node.
-        label: An optional label for the node, providing additional context or classification.
+            related_nodes: A list of identifiers (str) for nodes that are related to this node.
+            label: An optional label for the node, providing additional context or classification.
     """
 
-    related_nodes: list[str] = pyd.ln_Field(default_factory=list)
+    related_nodes: list[str] = Field(default_factory=list)
     label: str | None = None
 
     def add_related_node(self, node_id: str) -> bool:
@@ -135,10 +132,10 @@ class BaseRelatableNode(BaseNode):
         Adds a node to the list of related nodes if it's not already present.
 
         Args:
-            node_id: The identifier of the node to add.
+                node_id: The identifier of the node to add.
 
         Returns:
-            bool: True if the node was added, False if it was already in the list.
+                bool: True if the node was added, False if it was already in the list.
         """
         if node_id not in self.related_nodes:
             self.related_nodes.append(node_id)
@@ -150,10 +147,10 @@ class BaseRelatableNode(BaseNode):
         Removes a node from the list of related nodes if it's present.
 
         Args:
-            node_id: The identifier of the node to remove.
+                node_id: The identifier of the node to remove.
 
         Returns:
-            bool: True if the node was removed, False if it was not found in the list.
+                bool: True if the node was removed, False if it was not found in the list.
         """
 
         if node_id in self.related_nodes:
@@ -167,10 +164,10 @@ class Tool(BaseRelatableNode):
     Represents a tool, extending BaseRelatableNode with specific functionalities and configurations.
 
     Attributes:
-        func: The main function or capability of the tool.
-        schema_: An optional schema defining the structure and constraints of data the tool works with.
-        manual: Optional documentation or manual for using the tool.
-        parser: An optional parser associated with the tool for data processing or interpretation.
+            func: The main function or capability of the tool.
+            schema_: An optional schema defining the structure and constraints of data the tool works with.
+            manual: Optional documentation or manual for using the tool.
+            parser: An optional parser associated with the tool for data processing or interpretation.
     """
 
     func: Any
@@ -178,7 +175,7 @@ class Tool(BaseRelatableNode):
     manual: Any | None = None
     parser: Any | None = None
 
-    @pyd.ln_field_serializer("func")
+    @field_serializer("func")
     def serialize_func(self, func):
         return func.__name__
 

lionagi/core/schema/condition.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+
+
+class SourceType(str, Enum):
+    STRUCTURE = "structure"
+    EXECUTABLE = "executable"
+
+
+class Condition(ABC):
+    def __init__(self, source_type):
+        try:
+            if isinstance(source_type, str):
+                source_type = SourceType(source_type)
+            if isinstance(source_type, SourceType):
+                self.source_type = source_type
+        except:
+            raise ValueError(
+                f"Invalid source_type. Valid source types are {list(SourceType)}"
+            )
+
+    @abstractmethod
+    def __call__(self, source_obj):
+        pass

lionagi/core/schema/data_logger.py

@@ -4,10 +4,10 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List
 
-from lionagi.libs.sys_util import SysUtil
+from lionagi.libs import SysUtil, convert, nested
 
-from lionagi.libs import ln_convert as convert
-from lionagi.libs import ln_nested as nested
+
+# TODO: there should be a global data logger, under setting
 
 
 @dataclass
@@ -23,12 +23,12 @@ class DLog:
     operations.
 
     Attributes:
-        input_data (Any): The data received by the operation. This attribute can be of
-                          any type, reflecting the flexible nature of input data to
-                          various processes.
-        output_data (Any): The data produced by the operation. Similar to `input_data`,
-                           this attribute supports any type, accommodating the diverse
-                           outputs that different operations may generate.
+            input_data (Any): The data received by the operation. This attribute can be of
+                                              any type, reflecting the flexible nature of input data to
+                                              various processes.
+            output_data (Any): The data produced by the operation. Similar to `input_data`,
+                                               this attribute supports any type, accommodating the diverse
+                                               outputs that different operations may generate.
 
     Methods: serialize: Converts the instance into a dictionary, suitable for
     serialization, and appends a timestamp to this dictionary, reflecting the current
@@ -46,8 +46,8 @@ class DLog:
         dictionary, capturing the exact time the log entry was serialized.
 
         Returns:
-            Dict[str, Any]: A dictionary representation of the DLog instance, including
-                            'input_data', 'output_data', and 'timestamp' keys.
+                Dict[str, Any]: A dictionary representation of the DLog instance, including
+                                                'input_data', 'output_data', and 'timestamp' keys.
         """
         log_dict = {}
 
@@ -83,8 +83,8 @@ class DLog:
         dictionary, capturing the exact time the log entry was serialized.
 
         Returns:
-            Dict[str, Any]: A dictionary representation of the DLog instance, including
-                            'input_data', 'output_data', and 'timestamp' keys.
+                Dict[str, Any]: A dictionary representation of the DLog instance, including
+                                                'input_data', 'output_data', and 'timestamp' keys.
         """
         input_data = ""
         output_data = ""
@@ -113,27 +113,27 @@ class DataLogger:
     at program exit, among other features.
 
     Attributes:
-        persist_path (Path): The filesystem path to the directory where log files will
-                             be saved. Defaults to a subdirectory 'data/logs/' within
-                             the current working directory.
-        log (Deque[Dict]): A deque object that acts as the container for log entries.
-                           Each log entry is stored as a dictionary, facilitating easy
-                           conversion to various data formats.
-        filename (str): The base name used for log files when saved. The actual filepath
-                        may include a timestamp or other modifiers based on the class's
-                        configuration.
+            persist_path (Path): The filesystem path to the directory where log files will
+                                                     be saved. Defaults to a subdirectory 'data/logs/' within
+                                                     the current working directory.
+            log (Deque[Dict]): A deque object that acts as the container for log entries.
+                                               Each log entry is stored as a dictionary, facilitating easy
+                                               conversion to various data formats.
+            filename (str): The base name used for log files when saved. The actual filepath
+                                            may include a timestamp or other modifiers based on the class's
+                                            configuration.
 
     Methods:
-        append: Adds a new log entry to the datalogger.
-        to_csv_file: Exports accumulated log entries to a CSV file.
-        to_json_file: Exports accumulated log entries to a JSON file.
-        save_at_exit: Ensures that unsaved log entries are persisted to a CSV file when
-                      the program terminates.
+            append: Adds a new log entry to the datalogger.
+            to_csv_file: Exports accumulated log entries to a CSV file.
+            to_json_file: Exports accumulated log entries to a JSON file.
+            save_at_exit: Ensures that unsaved log entries are persisted to a CSV file when
+                                      the program terminates.
 
     Usage Example:
-        >>> datalogger = DataLogger(persist_path='my/logs/directory', filepath='process_logs')
-        >>> datalogger.append(input_data="Example input", output_data="Example output")
-        >>> datalogger.to_csv_file('finalized_logs.csv', clear=True)
+            >>> datalogger = DataLogger(persist_path='my/logs/directory', filepath='process_logs')
+            >>> datalogger.append(input_data="Example input", output_data="Example output")
+            >>> datalogger.to_csv_file('finalized_logs.csv', clear=True)
 
     This example demonstrates initializing a `DataLogger` with a custom directory and
     filepath, appending a log entry, and then exporting the log to a CSV file.
@@ -151,18 +151,18 @@ class DataLogger:
         logs, and base filepath for exports.
 
         Args:
-            persist_path (str | Path | None, optional):
-                The file system path to the directory where log files will be persisted.
-                if not provided, defaults to 'data/logs/' within the current working
-                directory. this path is used for all subsequent log export operations.
-            log (list[Dict[str, Any]] | None, optional):
-                An initial collection of log entries to populate the datalogger. each entry
-                should be a dictionary reflecting the structure used by the datalogger
-                (input, output, timestamp). if omitted, the datalogger starts empty.
-            filename (str | None, optional):
-                The base name for exported log files. this name may be augmented with
-                timestamps and format-specific extensions during export operations.
-                defaults to 'log'.
+                persist_path (str | Path | None, optional):
+                        The file system path to the directory where log files will be persisted.
+                        if not provided, defaults to 'data/logs/' within the current working
+                        directory. this path is used for all subsequent log export operations.
+                log (list[Dict[str, Any]] | None, optional):
+                        An initial collection of log entries to populate the datalogger. each entry
+                        should be a dictionary reflecting the structure used by the datalogger
+                        (input, output, timestamp). if omitted, the datalogger starts empty.
+                filename (str | None, optional):
+                        The base name for exported log files. this name may be augmented with
+                        timestamps and format-specific extensions during export operations.
+                        defaults to 'log'.
 
         register an at-exit handler to ensure unsaved logs are automatically persisted to
         a CSV file upon program termination.
@@ -184,10 +184,10 @@ class DataLogger:
         record deque.
 
         Args:
-            input_data (Any):
-                Data provided as input to a tracked operation or process.
-            output_data (Any):
-                Data resulting from the operation, recorded as the output.
+                input_data (Any):
+                        Data provided as input to a tracked operation or process.
+                output_data (Any):
+                        Data resulting from the operation, recorded as the output.
 
         constructs a log entry from the provided data and automatically includes a
         timestamp upon serialization.
@@ -214,25 +214,25 @@ class DataLogger:
         and timestamping options.
 
         Args:
-            filename (str, optional):
-                Filename for the CSV output, appended with '.csv' if not included, saved
-                within the specified persisting directory.
-            dir_exist_ok (bool, optional):
-                If False, raises an error if the directory already exists; otherwise,
-                writes without an error.
-            timestamp (bool, optional):
-                If True, appends a current timestamp to the filepath for uniqueness.
-            time_prefix (bool, optional):
-                If True, place the timestamp prefix before the filepath; otherwise,
-                it's suffixed.
-            verbose (bool, optional):
-                If True, print a message upon successful file save, detailing the file
-                path and number of logs saved.
-            clear (bool, optional):
-                If True, empties the internal log record after saving.
-            **kwargs:
-                Additional keyword arguments for pandas.DataFrame.to_csv(), allowing
-                customization of the CSV output, such as excluding the index.
+                filename (str, optional):
+                        Filename for the CSV output, appended with '.csv' if not included, saved
+                        within the specified persisting directory.
+                dir_exist_ok (bool, optional):
+                        If False, raises an error if the directory already exists; otherwise,
+                        writes without an error.
+                timestamp (bool, optional):
+                        If True, appends a current timestamp to the filepath for uniqueness.
+                time_prefix (bool, optional):
+                        If True, place the timestamp prefix before the filepath; otherwise,
+                        it's suffixed.
+                verbose (bool, optional):
+                        If True, print a message upon successful file save, detailing the file
+                        path and number of logs saved.
+                clear (bool, optional):
+                        If True, empties the internal log record after saving.
+                **kwargs:
+                        Additional keyword arguments for pandas.DataFrame.to_csv(), allowing
+                        customization of the CSV output, such as excluding the index.
 
         raises a ValueError with an explanatory message if an error occurs during the file
         writing or DataFrame conversion process.
@@ -257,7 +257,7 @@ class DataLogger:
             if clear:
                 self.log.clear()
         except Exception as e:
-            raise ValueError(f"Error in saving to csv: {e}")
+            raise ValueError(f"Error in saving to csv: {e}") from e
 
     def to_json_file(
         self,
@@ -278,41 +278,41 @@ class DataLogger:
         offering customization for file naming and timestamping.
 
         Args:
-            filename (str, optional):
-                The filepath for the JSON output.'.json' is appended if not specified.
-                The file is saved within the designated persisting directory.
-            timestamp (bool, optional):
-                If True, adds a timestamp to the filepath to ensure uniqueness.
-            time_prefix (bool, optional):
-                Determines the placement of the timestamp in the filepath. A prefix if
-                True; otherwise, a suffix.
-            dir_exist_ok (bool, optional):
-                Allows writing to an existing directory without raising an error.
-                If False, an error is raised when attempting to write to an existing
-                directory.
-            verbose (bool, optional):
-                 Print a message upon successful save, indicating the file path and
-                number of logs saved.
-            clear (bool, optional):
-                Clears the log deque after saving, aiding in memory management.
-            **kwargs:
-                Additional arguments passed to pandas.DataFrame.to_json(),
-                enabling customization of the JSON output.
+                filename (str, optional):
+                        The filepath for the JSON output.'.json' is appended if not specified.
+                        The file is saved within the designated persisting directory.
+                timestamp (bool, optional):
+                        If True, adds a timestamp to the filepath to ensure uniqueness.
+                time_prefix (bool, optional):
+                        Determines the placement of the timestamp in the filepath. A prefix if
+                        True; otherwise, a suffix.
+                dir_exist_ok (bool, optional):
+                        Allows writing to an existing directory without raising an error.
+                        If False, an error is raised when attempting to write to an existing
+                        directory.
+                verbose (bool, optional):
+                         Print a message upon successful save, indicating the file path and
+                        number of logs saved.
+                clear (bool, optional):
+                        Clears the log deque after saving, aiding in memory management.
+                **kwargs:
+                        Additional arguments passed to pandas.DataFrame.to_json(),
+                        enabling customization of the JSON output.
 
         Raises:
-            ValueError: When an error occurs during file writing or DataFrame conversion,
-            encapsulating
-            the exception with a descriptive message.
+                ValueError: When an error occurs during file writing or DataFrame conversion,
+                encapsulating
+                the exception with a descriptive message.
 
         Examples:
-            Default usage saving logs to 'log.json' within the specified persisting
-            directory:
-            >>> datalogger.to_json_file()
-            # Save path: 'data/logs/log.json'
-
-            Custom filepath without a timestamp, using additional pandas options:
-            >>> datalogger.to_json_file(filepath='detailed_log.json', orient='records')
-            # Save a path: 'data/logs/detailed_log.json'
+                Default usage saving logs to 'log.json' within the specified persisting
+                directory:
+                >>> datalogger.to_json_file()
+                # Save path: 'data/logs/log.json'
+
+                Custom filepath without a timestamp, using additional pandas options:
+                >>> datalogger.to_json_file(filepath='detailed_log.json', orient='records')
+                # Save a path: 'data/logs/detailed_log.json'
         """
         if not filename.endswith(".json"):
             filename += ".json"
@@ -334,7 +334,7 @@ class DataLogger:
             if clear:
                 self.log.clear()
         except Exception as e:
-            raise ValueError(f"Error in saving to csv: {e}")
+            raise ValueError(f"Error in saving to csv: {e}") from e
 
     def save_at_exit(self):
         """

lionagi/core/schema/data_node.py

@@ -1,5 +1,5 @@
 from typing import Any
-from lionagi.core.schema.base_node import BaseNode
+from .base_node import BaseNode
 
 from lionagi.integrations.bridge import LlamaIndexBridge, LangchainBridge
 
@@ -22,15 +22,15 @@ class DataNode(BaseNode):
         integration and usage within that ecosystem.
 
         Args:
-            node_type:
-            **kwargs: Additional keyword arguments for customization.
+                node_type:
+                **kwargs: Additional keyword arguments for customization.
 
         Returns:
-            Any: The llama index format representation of the node.
+                Any: The llama index format representation of the node.
 
         Examples:
-            >>> node = DataNode(content="Example content")
-            >>> llama_index = node.to_llama_index()
+                >>> node = DataNode(content="Example content")
+                >>> llama_index = node.to_llama_index()
         """
         return LlamaIndexBridge.to_llama_index_node(self, node_type=node_type, **kwargs)
 
@@ -42,14 +42,14 @@ class DataNode(BaseNode):
         use within langchain_ applications and workflows.
 
         Args:
-            **kwargs: Additional keyword arguments for customization.
+                **kwargs: Additional keyword arguments for customization.
 
         Returns:
-            Any: The langchain_ document representation of the node.
+                Any: The langchain_ document representation of the node.
 
         Examples:
-            >>> node = DataNode(content="Example content")
-            >>> langchain_doc = node.to_langchain()
+                >>> node = DataNode(content="Example content")
+                >>> langchain_doc = node.to_langchain()
         """
         return LangchainBridge.to_langchain_document(self, **kwargs)
 
@@ -59,15 +59,15 @@ class DataNode(BaseNode):
         Creates a DataNode instance from a llama index node.
 
         Args:
-            llama_node: The llama index node object.
-            **kwargs: Variable length argument list.
+                llama_node: The llama index node object.
+                **kwargs: Variable length argument list.
 
         Returns:
-            An instance of DataNode.
+                An instance of DataNode.
 
         Examples:
-            llama_node = SomeLlamaIndexNode()
-            data_node = DataNode.from_llama_index(llama_node)
+                llama_node = SomeLlamaIndexNode()
+                data_node = DataNode.from_llama_index(llama_node)
         """
         llama_dict = llama_node.to_dict(**kwargs)
         return cls.from_obj(llama_dict)
@@ -78,14 +78,14 @@ class DataNode(BaseNode):
         Creates a DataNode instance from a langchain_ document.
 
         Args:
-            lc_doc: The langchain_ document object.
+                lc_doc: The langchain_ document object.
 
         Returns:
-            An instance of DataNode.
+                An instance of DataNode.
 
         Examples:
-            lc_doc = SomeLangChainDocument()
-            data_node = DataNode.from_langchain(lc_doc)
+                lc_doc = SomeLangChainDocument()
+                data_node = DataNode.from_langchain(lc_doc)
         """
         info_json = lc_doc.to_json()
         info_node = {"lc_id": info_json["id"]}