lionagi 0.5.5__py3-none-any.whl → 0.6.1__py3-none-any.whl

lionagi/core/session/session.py

@@ -1,163 +0,0 @@
-# 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.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):
-    """
-    Manages multiple conversation branches and mail transfer in a session.
-
-    Attributes:
-        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.
-    """
-
-    branches: Pile = Field(default_factory=Pile)
-    default_branch: Branch = Field(default_factory=Branch, exclude=True)
-
-    def new_branch(
-        self,
-        system: System | JsonValue = None,
-        system_sender: ID.SenderRecipient = None,
-        system_datetime: bool | str = None,
-        user: ID.SenderRecipient = None,
-        name: str | None = None,
-        imodel: iModel | None = None,
-        messages: Pile[RoledMessage] = None,
-        progress: Progression = None,
-        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 remove_branch(
-        self,
-        branch: ID.Ref,
-        delete: bool = False,
-    ):
-        branch = ID.get_id(branch)
-
-        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]
-
-        if delete:
-            del branch
-
-    async def asplit(self, branch: ID.Ref) -> Branch:
-        """
-        Split a branch, creating a new branch with the same messages and tools.
-
-        Args:
-            branch: The branch to split or its identifier.
-
-        Returns:
-            The newly created branch.
-        """
-        async with self.branches:
-            return self.split(branch)
-
-    def split(self, branch: ID.Ref) -> Branch:
-        """
-        Split a branch, creating a new branch with the same messages and tools.
-
-        Args:
-            branch: The branch to split or its identifier.
-
-        Returns:
-            The newly created branch.
-        """
-        branch: Branch = self.branches[branch]
-        branch_clone = branch.clone(sender=self.ln_id)
-        self.branches.append(branch_clone)
-        return branch_clone
-
-    def change_default_branch(self, branch: ID.Ref):
-        """
-        Change the default branch of the session.
-
-        Args:
-            branch: The branch to set as default or its identifier.
-        """
-        branch = self.branches[branch]
-        if not isinstance(branch, Branch):
-            raise ValueError("Input value for branch is not a valid branch.")
-        self.default_branch = branch
-
-    def to_df(self, branches: ID.RefSeq = None) -> pd.DataFrame:
-        out = self.concat_messages(branches=branches)
-        return out.to_df(columns=MESSAGE_FIELDS)
-
-    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)
-
-        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."
-                )
-
-            b: Branch = self.branches[i]
-            out |= b.msgs.messages
-
-        return out
-
-
-__all__ = ["Session"]
-# File: autoos/session/session.py

lionagi/core/session/types.py

@@ -1,8 +0,0 @@
-# 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

@@ -1,9 +0,0 @@
-# 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

@@ -1,173 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-import uuid
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from typing import Any, Generic, TypeVar
-
-from lionagi.settings import Settings
-
-
-class IDType:
-
-    def __init__(self, _id: uuid.UUID):
-        self._id = _id
-
-    @classmethod
-    def validate(cls, value) -> IDType:
-        if isinstance(value, cls):
-            return value
-        if isinstance(value, str | int):
-            try:
-                _id = uuid.UUID(value, version=Settings.Config.UUID_VERSION)
-                return cls(_id=_id)
-            except Exception as e:
-                raise ValueError(f"Invalid IDType value: {value}") from e
-        raise ValueError(f"Invalid IDType value: {value}")
-
-    def __str__(self):
-        return str(self._id)
-
-    def __repr__(self):
-        return f"{self.__class__.__name__}({self._id})"
-
-    def __hash__(self):
-        return hash(self._id)
-
-    def __eq__(self, other):
-        if not isinstance(other, IDType):
-            return False
-        return self._id == other._id
-
-    __slots__ = ("_id",)
-
-
-class Observable(ABC):
-    """
-    Abstract base class for objects that can be uniquely identified and tracked.
-
-    All Observable objects must have a unique identifier (id) that allows them
-    to be tracked and referenced within the Lion system.
-    """
-
-    ln_id: IDType
-
-
-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",
-    "IDType",
-]

lionagi/core/typing/_id.py

@@ -1,104 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-import uuid
-
-from lionagi.settings import Settings
-
-from ._concepts import (
-    Container,
-    Generic,
-    IDType,
-    ItemError,
-    Observable,
-    Ordering,
-    T,
-)
-from ._typing import Container, Mapping, Sequence, TypeAlias
-
-
-class IDError(ItemError):
-    """Exception raised when an item does not have a Lion ID."""
-
-    def __init__(
-        self,
-        message: str = "Item must contain a Lion ID.",
-        item_id: str | None = None,
-    ):
-        super().__init__(message, item_id)
-
-
-class ID(Generic[T]):
-    """
-    A generic class that provides ID-related functionality for Observable objects.
-
-    This class handles the generation, validation, and management of unique identifiers
-    within the Lion system. It provides type aliases for various ID-related operations
-    and methods for working with IDs.
-    """
-
-    # For functions that accept either ID or item
-    Ref: TypeAlias = IDType | T  # type: ignore
-
-    # For functions requiring just the ID
-    ID: TypeAlias = IDType
-
-    # For functions requiring Observable object
-    Item = T  # type: ignore
-
-    # For collections
-    IDSeq: TypeAlias = list[IDType] | Ordering
-    ItemSeq: TypeAlias = (  # type: ignore
-        Sequence[T] | Mapping[IDType, T] | Container[IDType | T]
-    )
-    RefSeq: TypeAlias = IDSeq | ItemSeq
-
-    # For system-level interactions
-    SenderRecipient: TypeAlias = IDType | T | str  # type: ignore
-
-    @staticmethod
-    def id():
-        return IDType(
-            _id=getattr(uuid, f"uuid{Settings.Config.UUID_VERSION}")()
-        )
-
-    @staticmethod
-    def get_id(item, /) -> IDType:
-
-        if isinstance(item, Observable):
-            return item.ln_id
-        try:
-            return IDType.validate(item)
-        except ValueError as e:
-            raise IDError(
-                f"The input object of type <{type(item).__name__}> does "
-                "not contain or is not a valid Lion ID. Item must be an instance"
-                " of `Observable` or a valid `id`."
-            ) from e
-
-    @staticmethod
-    def is_id(item, /) -> bool:
-        """
-        Check if an item is or contains a valid Lion ID.
-
-        Args:
-            item: The item to check.
-            config: Configuration dictionary for ID validation.
-
-        Returns:
-            True if the item is a valid Lion ID, False otherwise.
-        """
-        try:
-            ID.get_id(item)
-            return True
-        except IDError:
-            return False
-
-
-__all__ = [
-    "ID",
-    "IDError",
-]

lionagi/core/typing/_pydantic.py

@@ -1,33 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    Field,
-    JsonValue,
-    PrivateAttr,
-    create_model,
-    field_serializer,
-    field_validator,
-    model_serializer,
-    model_validator,
-)
-from pydantic.fields import FieldInfo
-from pydantic_core import PydanticUndefined
-
-__all__ = [
-    "BaseModel",
-    "ConfigDict",
-    "Field",
-    "JsonValue",
-    "PrivateAttr",
-    "FieldInfo",
-    "PydanticUndefined",
-    "field_validator",
-    "model_validator",
-    "model_serializer",
-    "field_serializer",
-    "create_model",
-]

lionagi/core/typing/_typing.py

@@ -1,54 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from abc import ABC
-from collections.abc import (
-    Callable,
-    Container,
-    ItemsView,
-    Iterator,
-    Mapping,
-    Sequence,
-    ValuesView,
-)
-from enum import Enum
-from typing import (
-    Annotated,
-    Any,
-    ClassVar,
-    Generic,
-    Literal,
-    NoReturn,
-    Self,
-    TypeAlias,
-    TypeVar,
-)
-
-from typing_extensions import override
-
-from lionagi.libs.constants import UNDEFINED, UndefinedType
-
-__all__ = [
-    "ABC",
-    "Annotated",
-    "Any",
-    "ClassVar",
-    "Container",
-    "Enum",
-    "Generic",
-    "Literal",
-    "Mapping",
-    "NoReturn",
-    "Sequence",
-    "TypeAlias",
-    "TypeVar",
-    "UndefinedType",
-    "UNDEFINED",
-    "override",
-    "Callable",
-    "Self",
-    "Iterator",
-    "ValuesView",
-    "ItemsView",
-]

lionagi/integrations/_services.py

@@ -1,17 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from .anthropic_.AnthropicService import AnthropicService
-from .groq_.GroqService import GroqService
-from .ollama_.OllamaService import OllamaService
-from .openai_.OpenAIService import OpenAIService
-from .perplexity_.PerplexityService import PerplexityService
-
-__all__ = (
-    "AnthropicService",
-    "GroqService",
-    "OllamaService",
-    "OpenAIService",
-    "PerplexityService",
-)