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

lionagi/protocols/adapters/adapter.py

@@ -0,0 +1,79 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from typing import Any, Protocol, TypeVar, runtime_checkable
+
+from typing_extensions import get_protocol_members
+
+T = TypeVar("T")
+
+
+@runtime_checkable
+class Adapter(Protocol):
+
+    obj_key: str
+
+    @classmethod
+    def from_obj(
+        cls, subj_cls: type[T], obj: Any, /, **kwargs
+    ) -> dict | list[dict]: ...
+
+    @classmethod
+    def to_obj(cls, subj: T, /, **kwargs) -> Any: ...
+
+
+adapter_members = get_protocol_members(Adapter)  # duck typing
+
+
+class AdapterRegistry:
+
+    _adapters: dict[str, Adapter] = {}
+
+    @classmethod
+    def list_adapters(cls) -> list[tuple[str | type, ...]]:
+        return list(cls._adapters.keys())
+
+    @classmethod
+    def register(cls, adapter: type[Adapter]) -> None:
+        for member in adapter_members:
+            if not hasattr(adapter, member):
+                _str = getattr(adapter, "obj_key", None) or repr(adapter)
+                _str = _str[:50] if len(_str) > 50 else _str
+                raise AttributeError(
+                    f"Adapter {_str} missing required methods."
+                )
+
+        if isinstance(adapter, type):
+            cls._adapters[adapter.obj_key] = adapter()
+        else:
+            cls._adapters[adapter.obj_key] = adapter
+
+    @classmethod
+    def get(cls, obj_key: type | str) -> Adapter:
+        try:
+            return cls._adapters[obj_key]
+        except Exception as e:
+            logging.error(f"Error getting adapter for {obj_key}. Error: {e}")
+
+    @classmethod
+    def adapt_from(
+        cls, subj_cls: type[T], obj: Any, obj_key: type | str, **kwargs
+    ) -> dict | list[dict]:
+        try:
+            return cls.get(obj_key).from_obj(subj_cls, obj, **kwargs)
+        except Exception as e:
+            logging.error(f"Error adapting data from {obj_key}. Error: {e}")
+            raise e
+
+    @classmethod
+    def adapt_to(cls, subj: T, obj_key: type | str, **kwargs) -> Any:
+        try:
+            return cls.get(obj_key).to_obj(subj, **kwargs)
+        except Exception as e:
+            logging.error(f"Error adapting data to {obj_key}. Error: {e}")
+            raise e
+
+
+__all__ = ["AdapterRegistry", "Adapter"]

lionagi/protocols/adapters/json_adapter.py

@@ -0,0 +1,43 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+import logging
+from pathlib import Path
+
+from lionagi.protocols.adapters.adapter import Adapter, T
+
+
+class JsonAdapter(Adapter):
+
+    obj_key = "json"
+
+    @classmethod
+    def from_obj(cls, subj_cls: type[T], obj: str, /) -> dict:
+        return json.loads(obj)
+
+    @classmethod
+    def to_obj(cls, subj: T) -> str:
+        return json.dumps(subj.to_dict())
+
+
+class JsonFileAdapter(Adapter):
+
+    obj_key = ".json"
+
+    @classmethod
+    def from_obj(cls, subj_cls: type[T], obj: str | Path, /) -> dict:
+        with open(obj) as f:
+            return json.load(f)
+
+    @classmethod
+    def to_obj(
+        cls,
+        subj: T,
+        /,
+        fp: str | Path,
+    ) -> None:
+        with open(fp, "w") as f:
+            json.dump(subj.to_dict(), f)
+        logging.info(f"Successfully saved data to {fp}")

lionagi/protocols/adapters/pandas_adapter.py

@@ -0,0 +1,96 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from pathlib import Path
+
+import pandas as pd
+
+from lionagi.integrations.pandas_ import to_df
+from lionagi.protocols.adapters.adapter import Adapter, T
+
+
+class PandasSeriesAdapter(Adapter):
+
+    obj_key = "pd_series"
+    alias = ("pandas_series", "pd.series", "pd_series")
+
+    @classmethod
+    def from_obj(cls, subj_cls: type[T], obj: pd.Series, /, **kwargs) -> dict:
+        return obj.to_dict(**kwargs)
+
+    @classmethod
+    def to_obj(cls, subj: T, /, **kwargs) -> pd.Series:
+        return pd.Series(subj.to_dict(), **kwargs)
+
+
+class PandasDataFrameAdapter(Adapter):
+
+    obj_key = "pd_dataframe"
+    alias = ("pandas_dataframe", "pd.DataFrame", "pd_dataframe")
+
+    @classmethod
+    def from_obj(
+        cls, subj_cls: type[T], obj: pd.DataFrame, /, **kwargs
+    ) -> list[dict]:
+        """kwargs for pd.DataFrame.to_dict"""
+        return obj.to_dict(orient="records", **kwargs)
+
+    @classmethod
+    def to_obj(cls, subj: list[T], /, **kwargs) -> pd.DataFrame:
+        """kwargs for pd.DataFrame"""
+        out_ = []
+        for i in subj:
+            _dict = i.to_dict()
+            _dict["timestamp"] = i.created_datetime
+            out_.append(_dict)
+        df = to_df(out_, **kwargs)
+        if "timestamp" in df.columns:
+            df["timestamp"] = pd.to_datetime(df["timestamp"])
+        return df
+
+
+class CSVFileAdapter(Adapter):
+
+    obj_key = ".csv"
+    alias = (".csv", "csv_file", "csv")
+
+    @classmethod
+    def from_obj(
+        cls, subj_cls: type[T], obj: str | Path, /, **kwargs
+    ) -> list[dict]:
+        """kwargs for pd.read_csv"""
+        df = pd.read_csv(obj, **kwargs)
+        return df.to_dict(orient="records")
+
+    @classmethod
+    def to_obj(
+        cls,
+        subj: list[T],
+        /,
+        fp: str | Path,
+        **kwargs,
+    ) -> None:
+        """kwargs for pd.DataFrame.to_csv"""
+        kwargs["index"] = False
+        to_df([i.to_dict() for i in subj]).to_csv(fp, **kwargs)
+        logging.info(f"Successfully saved data to {fp}")
+
+
+class ExcelFileAdapter(Adapter):
+
+    obj_key = ".xlsx"
+    alias = (".xlsx", "excel_file", "excel", "xlsx", "xls", ".xls")
+
+    @classmethod
+    def from_obj(
+        cls, subj_cls: type[T], obj: str | Path, /, **kwargs
+    ) -> list[dict]:
+        return pd.read_excel(obj, **kwargs).to_dict(orient="records")
+
+    @classmethod
+    def to_obj(cls, subj: list[T], /, fp: str | Path, **kwargs) -> None:
+        kwargs["index"] = False
+        to_df([i.to_dict() for i in subj]).to_excel(fp, **kwargs)
+        logging.info(f"Saved {subj.class_name()} to {fp}")

lionagi/protocols/configs/__init__.py

@@ -0,0 +1,15 @@
+from .branch_config import BranchConfig, MessageConfig
+from .id_config import LionIDConfig
+from .imodel_config import iModelConfig
+from .log_config import LogConfig
+from .retry_config import RetryConfig, TimedFuncCallConfig
+
+__all__ = [
+    "LogConfig",
+    "LionIDConfig",
+    "RetryConfig",
+    "TimedFuncCallConfig",
+    "iModelConfig",
+    "BranchConfig",
+    "MessageConfig",
+]

lionagi/protocols/configs/branch_config.py

@@ -0,0 +1,86 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Literal
+
+from lionagi.core.models.schema_model import SchemaModel
+from lionagi.core.typing.pydantic_ import Field
+
+from .imodel_config import iModelConfig
+from .log_config import LogConfig
+from .retry_config import TimedFuncCallConfig
+
+
+class MessageConfig(SchemaModel):
+    """Configuration for message handling in Branch"""
+
+    validation_mode: Literal["raise", "return_value", "return_none"] = Field(
+        default="return_value",
+        description="How to handle message validation failures",
+    )
+    auto_retries: bool = Field(
+        False, description="Whether to automatically retry message parsing"
+    )
+
+    max_retries: int = Field(
+        default=0, description="Maximum retries for message parsing"
+    )
+    allow_actions: bool = Field(
+        default=True,
+        description="Whether to allow action requests in messages",
+    )
+    auto_invoke_action: bool = Field(
+        default=True, description="Whether to automatically invoke actions"
+    )
+
+
+class BranchConfig(SchemaModel):
+    """Main configuration for Branch class.
+
+    Combines all aspects of Branch configuration including logging,
+    message handling, tool management, and iModel integration.
+    """
+
+    name: str | None = Field(
+        default=None, description="Branch name for identification"
+    )
+    user: str | None = Field(
+        default=None, description="User ID/name for the branch"
+    )
+    message_log_config: LogConfig = Field(
+        default_factory=LogConfig,
+        description="Configuration for log management",
+    )
+    action_log_config: LogConfig = Field(
+        default_factory=LogConfig,
+        description="Configuration for action log management",
+    )
+    message_config: MessageConfig = Field(
+        default_factory=MessageConfig,
+        description="Configuration for message handling",
+    )
+    auto_register_tools: bool = Field(
+        default=True,
+        description="Whether to automatically register tools when needed",
+    )
+    action_call_config: TimedFuncCallConfig = Field(
+        default_factory=TimedFuncCallConfig,
+        description="Configuration for action execution",
+    )
+    imodel_config: iModelConfig | None = Field(
+        default=None, description="Configuration for iModel integration"
+    )
+    retry_imodel_config: iModelConfig | None = Field(
+        default=None, description="Configuration for iModel integration"
+    )
+    kwargs: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Additional branch-specific configurations",
+    )
+
+
+__all__ = [
+    "MessageConfig",
+    "BranchConfig",
+]

lionagi/protocols/configs/id_config.py

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

lionagi/protocols/configs/imodel_config.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+import os
+
+from lionagi.core.models.schema_model import SchemaModel
+from lionagi.core.typing.pydantic_ import Field
+from lionagi.core.typing.typing_ import Any
+
+
+class iModelConfig(SchemaModel):
+    """Configuration for iModel service interaction.
+
+    Provides explicit configuration for iModel services. Users must specify
+    the environment variable name that contains their API key.
+
+    Basic Usage:
+        >>> config = iModelConfig(
+        ...     provider="anthropic",
+        ...     api_key_env="MY_ANTHROPIC_KEY",
+        ...     model="claude-3"
+        ... )
+        >>> imodel = iModel(**config.dict())
+    """
+
+    provider: str = Field(..., description="Service provider name")
+    api_key: str = Field(
+        ..., description="Environment variable name containing API key"
+    )
+    task: str = Field(
+        default="chat", description="Task type for model interface"
+    )
+    model: str | None = Field(default=None, description="Model identifier")
+    interval_tokens: int | None = Field(
+        default=None, description="Token limit per minute"
+    )
+    interval_requests: int | None = Field(
+        default=None, description="Request limit per minute"
+    )
+    kwargs: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Additional provider-specific arguments",
+    )
+
+    @classmethod
+    def load_json(cls, file_path: str) -> "iModelConfig":
+        """Load configuration from a JSON file."""
+        try:
+            data = json.load(file_path)
+            out = cls(**data)
+            validate_api_key(out.api_key)
+            return out
+        except Exception as e:
+            raise ValueError(
+                f"Error loading configuration from {file_path}: {e}"
+            )
+
+
+def validate_api_key(v: str) -> str:
+    """Validate API key environment variable exists."""
+    if not os.getenv(v):
+        if len(v) > 10:
+            v = v[:10] + "..."
+        raise ValueError(
+            f"API Key Environment variable '{v}' not found or empty. "
+            "Please set your API key in the specified environment "
+            "variable. Never directly input API keys in config files."
+        )
+
+
+__all__ = ["iModelConfig"]

lionagi/protocols/configs/log_config.py

@@ -0,0 +1,93 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+from typing import Any
+
+from pydantic import field_validator
+
+from lionagi.core.models.schema_model import SchemaModel
+from lionagi.core.typing.pydantic_ import Field
+
+
+class LogConfig(SchemaModel):
+    """Configuration for log management.
+
+    This class defines all configuration options for LogManager behavior
+    including file paths, persistence strategies, and capacity management.
+
+    Attributes:
+        persist_dir: Base directory for log storage
+        subfolder: Optional subfolder within persist_dir
+        file_prefix: Prefix for log filenames
+        capacity: Maximum logs before auto-dump
+        extension: File extension for log files
+        use_timestamp: Whether to include timestamps in filenames
+        hash_digits: Random hash digits in filenames
+        auto_save_on_exit: Whether to save on program exit
+        clear_after_dump: Whether to clear after dumping
+
+    Example:
+        >>> config = LogConfig(
+        ...     persist_dir="./logs",
+        ...     capacity=1000,
+        ...     file_prefix="service_"
+        ... )
+        >>> manager = LogManager.from_config(config)
+    """
+
+    # Basic settings
+    persist_dir: Path | str | None = Field(
+        default="./data/logs", description="Base directory for log persistence"
+    )
+    subfolder: str | None = Field(
+        default=None,
+        description="Optional subfolder within persist_dir",
+    )
+    file_prefix: str | None = Field(
+        default=None, description="Prefix for log filenames"
+    )
+    capacity: int | None = Field(
+        default=None,
+        description="Maximum number of logs to keep in memory before dumping",
+    )
+
+    # File configuration
+    extension: str = Field(
+        default=".csv",
+        description="File extension for log files",
+        pattern=r"^\.[a-zA-Z0-9]+$",
+    )
+    use_timestamp: bool = Field(
+        default=True, description="Whether to include timestamp in filenames"
+    )
+    hash_digits: int = Field(
+        default=5,
+        description="Number of random hash digits to add to filenames",
+        ge=0,
+        le=10,
+    )
+
+    # Behavior settings
+    auto_save_on_exit: bool = Field(
+        default=True,
+        description="Whether to automatically save logs when program exits",
+    )
+    clear_after_dump: bool = Field(
+        default=True, description="Whether to clear logs after dumping to file"
+    )
+
+    @field_validator("persist_dir")
+    def validate_persist_dir(cls, v: Any) -> Path:
+        """Validate and convert persist_dir to Path."""
+        if v is None:
+            return Path("./data/logs")
+        return Path(v)
+
+    @field_validator("capacity")
+    def validate_capacity(cls, v: Any) -> int | None:
+        """Validate capacity is positive if set."""
+        if v is not None and v <= 0:
+            raise ValueError("Capacity must be positive")
+        return v

lionagi/protocols/configs/retry_config.py

@@ -0,0 +1,29 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+from lionagi.core.models.schema_model import SchemaModel
+from lionagi.libs.constants import UNDEFINED, UndefinedType
+
+
+class TimedFuncCallConfig(SchemaModel):
+    initial_delay: int = 0
+    retry_default: str | UndefinedType = UNDEFINED
+    retry_timeout: int | None = None
+    retry_timing: bool = False
+    error_msg: str | None = None
+    error_map: dict | None = None
+
+
+class RetryConfig(SchemaModel):
+    num_retries: int = 0
+    initial_delay: int = 0
+    retry_delay: int = 0
+    backoff_factor: int = 1
+    retry_default: str | UndefinedType = UNDEFINED
+    retry_timeout: int | None = None
+    retry_timing: bool = False
+    verbose_retry: bool = False
+    error_msg: str | None = None
+    error_map: dict | None = None

lionagi/protocols/operatives/__init__.py

@@ -0,0 +1,15 @@
+from .action import ActionRequestModel, ActionResponseModel
+from .instruct import Instruct
+from .operative import Operative
+from .reason import ReasonModel
+from .step import Step, StepModel
+
+__all__: list[str] = [
+    "Operative",
+    "Step",
+    "ActionRequestModel",
+    "ActionResponseModel",
+    "StepModel",
+    "Instruct",
+    "ReasonModel",
+]