lionagi 0.3.8__py3-none-any.whl → 0.5.0__py3-none-any.whl

lionagi/core/session/session.py

@@ -1,299 +1,164 @@
-from typing import Any
-
-from lionagi.core.action.tool_manager import ToolManager
-from lionagi.core.collections import (
-    Exchange,
-    Pile,
-    Progression,
-    iModel,
-    pile,
-    progression,
-)
-from lionagi.core.collections.abc import get_lion_id
-from lionagi.core.collections.util import to_list_type
-from lionagi.core.mail.mail_manager import MailManager
-from lionagi.core.message import System
-from lionagi.core.session.branch import Branch
-from lionagi.libs import SysUtil
-
-
-class Session:
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Callable
+
+import pandas as pd
+
+from lionagi.core.generic.types import Component, Pile, Progression
+from lionagi.core.typing import ID, Field, ItemNotFoundError, JsonValue
+from lionagi.integrations.litellm_.imodel import LiteiModel
+from lionagi.libs.parse import to_list
+from lionagi.service import iModel
+
+from ..action.action_manager import ActionManager, Tool
+from ..communication.message import MESSAGE_FIELDS, RoledMessage
+from ..communication.system import System
+from .branch import Branch
+
+
+class Session(Component):
     """
-    A session for managing branches, mail transfer, and interactions with a model.
+    Manages multiple conversation branches and mail transfer in a session.
 
     Attributes:
-        ln_id (str): The unique identifier for the session.
-        timestamp (str): The timestamp when the session was created.
-        system (System): The default system message for the session.
-        system_sender (str): The sender of the system message.
-        branches (Pile[Branch]): The pile of branches in the session.
-        mail_transfer (Exchange): The exchange for managing mail transfer.
-        mail_manager (MailManager): The manager for handling mail.
-        imodel (iModel): The model associated with the session.
-        user (str): The user associated with the session.
-        default_branch (Branch): The default branch of the session.
+        branches (Pile | None): Collection of conversation branches.
+        default_branch (Branch | None): The default conversation branch.
+        mail_transfer (Exchange | None): Mail transfer system.
+        mail_manager (MailManager | None): Manages mail operations.
     """
 
-    def __init__(
-        self,
-        system=None,  # the default system message for the session
-        branches: Any | None = None,
-        system_sender: str | None = None,
-        user: str | None = None,
-        imodel=None,
-        tools=None,
-    ):
-        self.ln_id = SysUtil.create_id()
-        self.timestamp = SysUtil.get_timestamp(sep=None)[:-6]
-        system = (
-            system or "You are a helpful assistant, let's think step by step"
-        )
-        self.system = System(system=system, sender=system_sender)
-        self.system_sender = system_sender
-        self.branches: Pile[Branch] = self._validate_branches(branches)
-        self.mail_transfer = Exchange()
-        self.mail_manager = MailManager([self.mail_transfer])
-        self.imodel = imodel or iModel()
-        self.user = user
-        self.default_branch = None
-        if self.branches.size() == 0:
-            self.new_branch(system=self.system.clone())
-        else:
-            self.default_branch = self.branches[0]
-        if tools:
-            self.default_branch.tool_manager.register_tools(tools)
-
-    def _validate_branches(self, value):
-        """
-        Validates and converts the branches input to a Pile of Branch objects.
-
-        Args:
-            value (Any): The input value to validate and convert.
+    branches: Pile = Field(default_factory=Pile)
+    default_branch: Branch = Field(default_factory=Branch, exclude=True)
 
-        Returns:
-            Pile[Branch]: A pile of validated branches.
-
-        Raises:
-            ValueError: If the input value contains non-Branch objects.
-        """
-        if isinstance(value, Pile):
-            for branch in value:
-                if not isinstance(branch, Branch):
-                    raise ValueError(
-                        "The branches pile contains non-Branch object"
-                    )
-            return value
-        else:
-            try:
-                value = pile(items=value, item_type=Branch)
-                return value
-            except Exception as e:
-                raise ValueError(f"Invalid branches value. Error:{e}")
-
-    # ---- branch manipulation ---- #
     def new_branch(
         self,
-        system: System | None = None,
-        system_sender: str | None = None,
-        user: str | None = None,
-        messages: Pile = None,
+        system: System | JsonValue = None,
+        system_sender: ID.SenderRecipient = None,
+        system_datetime: bool | str = None,
+        user: ID.SenderRecipient = None,
+        name: str | None = None,
+        imodel: iModel | LiteiModel | None = None,
+        messages: Pile[RoledMessage] = None,
         progress: Progression = None,
-        tool_manager: ToolManager = None,
-        tools: Any = None,
-        imodel=None,
-    ):
-        """
-        Creates a new branch and adds it to the session.
-
-        Args:
-            system (System, optional): The system message for the branch.
-            system_sender (str, optional): The sender of the system message.
-            user (str, optional): The user associated with the branch.
-            messages (Pile, optional): The pile of messages for the branch.
-            progress (Progression, optional): The progression of messages.
-            tool_manager (ToolManager, optional): The tool manager for the branch.
-            tools (Any, optional): The tools to register with the tool manager.
-            imodel (iModel, optional): The model associated with the branch.
-
-        Returns:
-            Branch: The created branch.
-        """
-        if system is None:
-            system = self.system.clone()
-            system.sender = self.ln_id
-            system_sender = self.ln_id
-        branch = Branch(
-            system=system,
-            system_sender=system_sender,
-            user=user,
-            messages=messages,
-            progress=progress,
-            tool_manager=tool_manager,
-            tools=tools,
-            imodel=imodel or self.imodel,
-        )
-        self.branches.append(branch)
-        self.mail_manager.add_sources(branch)
+        tool_manager: ActionManager = None,
+        tools: Tool | Callable | list = None,
+        **kwargs,  # additional branch parameters
+    ) -> Branch:
+
+        kwargs["system"] = system
+        kwargs["system_sender"] = system_sender
+        kwargs["system_datetime"] = system_datetime
+        kwargs["user"] = user
+        kwargs["name"] = name
+        kwargs["imodel"] = imodel
+        kwargs["messages"] = messages
+        kwargs["progress"] = progress
+        kwargs["tool_manager"] = tool_manager
+        kwargs["tools"] = tools
+        kwargs = {k: v for k, v in kwargs.items() if v is not None}
+
+        branch = Branch(**kwargs)
+
+        self.branches.include(branch)
         if self.default_branch is None:
             self.default_branch = branch
         return branch
 
-    def delete_branch(self, branch):
-        """
-        Deletes a branch from the session.
-
-        Args:
-            branch (Branch | str): The branch or its ID to delete.
-        """
-        branch_id = get_lion_id(branch)
-        self.branches.pop(branch_id)
-        self.mail_manager.delete_source(branch_id)
+    def remove_branch(
+        self,
+        branch: ID.Ref,
+        delete: bool = False,
+    ):
+        branch = ID.get_id(branch)
 
-        if self.default_branch == branch:
-            if self.branches.size() == 0:
+        if branch not in self.branches:
+            _s = (
+                str(branch)
+                if len(str(branch)) < 10
+                else str(branch)[:10] + "..."
+            )
+            raise ItemNotFoundError(f"Branch {_s}.. does not exist.")
+        branch: Branch = self.branches[branch]
+
+        self.branches.exclude(branch)
+
+        if self.default_branch.ln_id == branch.ln_id:
+            if self.branches.is_empty():
                 self.default_branch = None
             else:
                 self.default_branch = self.branches[0]
 
-    def split_branch(self, branch):
+        if delete:
+            del branch
+
+    async def asplit(self, branch: ID.Ref) -> Branch:
         """
-        Splits a branch, creating a new branch with the same messages and tools.
+        Split a branch, creating a new branch with the same messages and tools.
 
         Args:
-            branch (Branch | str): The branch or its ID to split.
+            branch: The branch to split or its identifier.
 
         Returns:
-            Branch: The newly created branch.
+            The newly created branch.
         """
-        branch = self.branches[branch]
-        system = branch.system.clone() if branch.system else None
-        if system:
-            system.sender = branch.ln_id
-        progress = progression()
-        messages = pile()
-
-        for id_ in branch.progress:
-            clone_message = branch.messages[id_].clone()
-            progress.append(clone_message.ln_id)
-            messages.append(clone_message)
-
-        tools = (
-            list(branch.tool_manager.registry.values())
-            if branch.tool_manager.registry
-            else None
-        )
-        branch_clone = Branch(
-            system=system,
-            system_sender=branch.ln_id,
-            user=branch.user,
-            progress=progress,
-            messages=messages,
-            tools=tools,
-        )
-        for message in branch_clone.messages:
-            message.sender = branch.ln_id
-            message.recipient = branch_clone.ln_id
-        self.branches.append(branch_clone)
-        self.mail_manager.add_sources(branch_clone)
-        return branch_clone
+        async with self.branches:
+            return self.split(branch)
 
-    def change_default_branch(self, branch):
+    def split(self, branch: ID.Ref) -> Branch:
         """
-        Changes the default branch of the session.
+        Split a branch, creating a new branch with the same messages and tools.
 
         Args:
-            branch (Branch | str): The branch or its ID to set as the default.
-        """
-        branch = self.branches[branch]
-        self.default_branch = branch
-
-    def collect(self, from_: Branch | str | Pile[Branch] | None = None):
-        """
-        Collects mail from specified branches.
+            branch: The branch to split or its identifier.
 
-        Args:
-            from_ (Branch | str | Pile[Branch], optional): The branches to collect mail from.
-                If None, collects mail from all branches.
-        """
-        if from_ is None:
-            self.mail_manager.collect_all()
-        else:
-            try:
-                sources = to_list_type(from_)
-                for source in sources:
-                    self.mail_manager.collect(get_lion_id(source))
-            except Exception as e:
-                raise ValueError(f"Failed to collect mail. Error: {e}")
-
-    def send(self, to_: Branch | str | Pile[Branch] | None = None):
+        Returns:
+            The newly created branch.
         """
-        Sends mail to specified branches.
+        branch: Branch = self.branches[branch]
+        branch_clone = branch.clone(sender=self.ln_id)
+        self.branches.append(branch_clone)
+        return branch_clone
 
-        Args:
-            to_ (Branch | str | Pile[Branch], optional): The branches to send mail to.
-                If None, sends mail to all branches.
+    def change_default_branch(self, branch: ID.Ref):
         """
-        if to_ is None:
-            self.mail_manager.send_all()
-        else:
-            try:
-                sources = to_list_type(to_)
-                for source in sources:
-                    self.mail_manager.send(get_lion_id(source))
-            except Exception as e:
-                raise ValueError(f"Failed to send mail. Error: {e}")
-
-    def collect_send_all(self, receive_all=False):
-        """
-        Collects and sends mail for all branches, optionally receiving all mail.
+        Change the default branch of the session.
 
         Args:
-            receive_all (bool, optional): Whether to receive all mail for all branches.
-        """
-        self.collect()
-        self.send()
-        if receive_all:
-            for branch in self.branches:
-                branch.receive_all()
-
-    async def chat(self, *args, branch=None, **kwargs):
+            branch: The branch to set as default or its identifier.
         """
-        Initiates a chat interaction with a branch.
+        branch = self.branches[branch]
+        if branch and len(branch) == 1:
+            self.default_branch = branch
+        raise ValueError("Session can only have one default branch.")
 
-        Args:
-            *args: Positional arguments to pass to the chat method.
-            branch (Branch, optional): The branch to chat with. Defaults to the default branch.
-            **kwargs: Keyword arguments to pass to the chat method.
+    def to_df(self, branches: ID.RefSeq = None) -> pd.DataFrame:
+        out = self.concat_messages(branches=branches)
+        return out.to_df(columns=MESSAGE_FIELDS)
 
-        Returns:
-            Any: The result of the chat interaction.
+    def concat_messages(
+        self, branches: ID.RefSeq = None
+    ) -> Pile[RoledMessage]:
+        if not branches:
+            branches = self.branches
+        if isinstance(branches, dict):
+            branches = to_list(branches, use_values=True)
 
-        Raises:
-            ValueError: If the specified branch is not found in the session branches.
-        """
-        if branch is None:
-            branch = self.default_branch
-        if branch not in self.branches:
-            raise ValueError("Branch not found in session branches")
-        return await self.branches[branch].chat(*args, **kwargs)
+        out = Pile(item_type={RoledMessage})
+        for i in branches:
+            if i not in self.branches:
+                _msg = str(i)
+                _msg = _msg[:50] if len(_msg) > 50 else _msg
+                raise ItemNotFoundError(
+                    f"Branch <{_msg}> was not found in the session."
+                )
 
-    async def direct(self, *args, branch=None, **kwargs):
-        """
-        Initiates a direct interaction with a branch.
+            b: Branch = self.branches[i]
+            out |= b.msgs.messages
 
-        Args:
-            *args: Positional arguments to pass to the direct method.
-            branch (Branch, optional): The branch to interact with. Defaults to the default branch.
-            **kwargs: Keyword arguments to pass to the direct method.
+        return out
 
-        Returns:
-            Any: The result of the direct interaction.
 
-        Raises:
-            ValueError: If the specified branch is not found in the session branches.
-        """
-        if branch is None:
-            branch = self.default_branch
-        if branch not in self.branches:
-            raise ValueError("Branch not found in session branches")
-        return await self.branches[branch].direct(*args, **kwargs)
+__all__ = ["Session"]
+# File: autoos/session/session.py

lionagi/core/session/types.py

@@ -0,0 +1,8 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .branch import Branch
+from .session import Session
+
+__all__ = ["Session", "Branch"]

lionagi/core/typing/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from ..models import *
+from .concepts import *
+from .id import *
+from .pydantic_ import *
+from .typing_ import *

lionagi/core/typing/concepts.py

@@ -0,0 +1,132 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from typing import Any, Generic, TypeVar
+
+
+class Observable(ABC):
+    """
+    Abstract base class for objects that can be uniquely identified and tracked.
+
+    All Observable objects must have a unique identifier (ln_id) that allows them
+    to be tracked and referenced within the Lion system.
+    """
+
+    ln_id: str
+
+
+T = TypeVar("T", bound=Observable)
+
+
+class Container(ABC, Generic[T]):
+    """
+    Abstract base class for objects that can contain Observable items.
+
+    Generic type T must be a subclass of Observable.
+    """
+
+    pass
+
+
+class Ordering(ABC, Generic[T]):
+    """
+    Abstract base class for objects that maintain an ordered collection of items.
+
+    Generic type T must be a subclass of Observable.
+    """
+
+    pass
+
+
+class Communicatable(ABC):
+    """
+    Abstract base class for objects that can participate in communication.
+
+    Defines the interface for objects that can send and receive messages within
+    the Lion system.
+    """
+
+    pass
+
+
+class Relational(Observable):
+
+    pass
+
+
+class Event(ABC):
+
+    @abstractmethod
+    async def invoke(self, *args, **kwargs) -> Any:
+        pass
+
+
+class Condition(ABC):
+
+    @abstractmethod
+    async def apply(self, *args, **kwargs) -> bool:
+        pass
+
+
+class Structure(ABC):
+    pass
+
+
+class ItemError(Exception):
+    """Base exception for errors related to framework items."""
+
+    def __init__(
+        self,
+        message: str = "Item error.",
+        item_id: str | None = None,
+    ):
+        self.item_id = item_id
+        item_info = f" Item ID: {item_id}" if item_id else ""
+        super().__init__(f"{message}{item_info}")
+
+
+class ItemNotFoundError(ItemError):
+    """Exception raised when an item is not found."""
+
+    def __init__(
+        self,
+        message: str = "Item not found.",
+        item_id: str | None = None,
+    ):
+        super().__init__(message, item_id)
+
+
+class ItemExistsError(ItemError):
+    """Exception raised when an item already exists."""
+
+    def __init__(
+        self,
+        message: str = "Item already exists.",
+        item_id: str | None = None,
+    ):
+        super().__init__(message, item_id)
+
+
+class RelationError(Exception):
+    """Base exception for errors related to framework relations."""
+
+    def __init__(self, message: str = "Relation error."):
+        super().__init__(message)
+
+
+__all__ = [
+    "Observable",
+    "Container",
+    "Ordering",
+    "Communicatable",
+    "ItemError",
+    "ItemNotFoundError",
+    "ItemExistsError",
+    "Relational",
+    "Event",
+    "Condition",
+    "Structure",
+    "RelationError",
+]

lionagi/core/typing/config.py

@@ -0,0 +1,15 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pydantic import BaseModel
+
+
+class LionIDConfig(BaseModel):
+    n: int
+    random_hyphen: bool
+    num_hyphens: int
+    hyphen_start_index: int
+    hyphen_end_index: int
+    prefix: str = "ln"
+    postfix: str = ""