lionagi 0.5.4__py3-none-any.whl → 0.6.0__py3-none-any.whl

lionagi/protocols/adapters/pandas_adapter.py

@@ -1,96 +0,0 @@
-# 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/branch_config.py

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

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

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

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

@@ -1,29 +0,0 @@
-# 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/configs/types.py

@@ -1,15 +0,0 @@
-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/operatives/instruct.py

@@ -1,194 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-"""Field definitions and validation for InstructModel components."""
-
-from typing import Any, ClassVar
-
-from pydantic import JsonValue, field_validator
-
-from lionagi.core.models import FieldModel, SchemaModel
-from lionagi.core.models.base import BaseAutoModel
-from lionagi.libs.parse import validate_boolean
-
-from .prompts import (
-    actions_field_description,
-    context_field_description,
-    guidance_field_description,
-    instruction_field_description,
-    reason_field_description,
-)
-
-
-def validate_instruction(cls, value) -> JsonValue | None:
-    """Validates that the instruction is not empty or None and is in the correct format.
-
-    Args:
-        cls: The validator class method.
-        value (JsonValue | None): The instruction value to validate.
-
-    Returns:
-        JsonValue | None: The validated instruction or None if invalid.
-    """
-    if value is None or (isinstance(value, str) and not value.strip()):
-        return None
-    return value
-
-
-def validate_boolean_field(cls, value) -> bool | None:
-    """Validates boolean fields, allowing for flexible input formats.
-
-    Args:
-        cls: The validator class method.
-        value: The value to validate as boolean.
-
-    Returns:
-        bool | None: The validated boolean value or None if invalid.
-    """
-    try:
-        return validate_boolean(value)
-    except Exception:
-        return None
-
-
-# Field Models
-INSTRUCTION_FIELD = FieldModel(
-    name="instruction",
-    annotation=JsonValue | None,
-    default=None,
-    title="Primary Instruction",
-    description=instruction_field_description,
-    validator=validate_instruction,
-    validator_kwargs={"mode": "before"},
-)
-
-GUIDANCE_FIELD = FieldModel(
-    name="guidance",
-    annotation=JsonValue | None,
-    default=None,
-    title="Execution Guidance",
-    description=guidance_field_description,
-)
-
-CONTEXT_FIELD = FieldModel(
-    name="context",
-    annotation=JsonValue | None,
-    default=None,
-    title="Task Context",
-    description=context_field_description,
-)
-
-REASON_FIELD = FieldModel(
-    name="reason",
-    annotation=bool,
-    default=False,
-    title="Include Reasoning",
-    description=reason_field_description,
-    validator=validate_boolean_field,
-    validator_kwargs={"mode": "before"},
-)
-
-ACTIONS_FIELD = FieldModel(
-    name="actions",
-    annotation=bool,
-    default=False,
-    title="Require Actions",
-    description=actions_field_description,
-    validator=validate_boolean_field,
-    validator_kwargs={"mode": "before"},
-)
-
-
-class Instruct(SchemaModel):
-    """Model for defining instruction parameters and execution requirements.
-
-    Attributes:
-        instruction (JsonValue | None): The primary instruction.
-        guidance (JsonValue | None): Execution guidance.
-        context (JsonValue | None): Task context.
-        reason (bool): Whether to include reasoning.
-        actions (bool): Whether specific actions are required.
-    """
-
-    instruction: JsonValue | None = INSTRUCTION_FIELD.field_info
-    guidance: JsonValue | None = GUIDANCE_FIELD.field_info
-    context: JsonValue | None = CONTEXT_FIELD.field_info
-
-    @field_validator("instruction", **INSTRUCTION_FIELD.validator_kwargs)
-    def _validate_instruction(cls, v):
-        """Field validator for the 'instruction' field.
-
-        Args:
-            v: The value to validate.
-
-        Returns:
-            JsonValue | None: The validated instruction value.
-        """
-        return INSTRUCTION_FIELD.validator(cls, v)
-
-
-class OperationInstruct(Instruct):
-
-    reserved_kwargs: ClassVar[list[str]] = [
-        "operative_model",
-        "field_models",
-        "operative",
-        "reason",
-        "actions",
-        "request_params",
-        "response_params",
-    ]
-    reason: bool = REASON_FIELD.field_info
-    actions: bool = ACTIONS_FIELD.field_info
-
-    @field_validator("reason", **REASON_FIELD.validator_kwargs)
-    def _validate_reason(cls, v):
-        """Field validator for the 'reason' field.
-
-        Args:
-            v: The value to validate.
-
-        Returns:
-            bool | None: The validated boolean value.
-        """
-        return REASON_FIELD.validator(cls, v)
-
-    @field_validator("actions", **ACTIONS_FIELD.validator_kwargs)
-    def _validate_actions(cls, v):
-        """Field validator for the 'actions' field.
-
-        Args:
-            v: The value to validate.
-
-        Returns:
-            bool | None: The validated boolean value.
-        """
-        return ACTIONS_FIELD.validator(cls, v)
-
-
-INSTRUCT_FIELD_MODEL = FieldModel(
-    name="instruct_models",
-    annotation=list[Instruct],
-    default_factory=list,
-    title="Instruction Model",
-    description="Model for defining instruction parameters and execution requirements.",
-)
-
-
-class InstructResponse(BaseAutoModel):
-    instruct: Instruct
-    response: Any | None = None
-
-
-# Export all components
-__all__ = [
-    "INSTRUCTION_FIELD",
-    "GUIDANCE_FIELD",
-    "CONTEXT_FIELD",
-    "REASON_FIELD",
-    "ACTIONS_FIELD",
-    "Instruct",
-    "INSTRUCT_FIELD_MODEL",
-    "InstructResponse",
-]

lionagi/protocols/operatives/types.py

@@ -1,19 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-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",
-]

lionagi/protocols/registries/_component_registry.py

@@ -1,23 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from lionagi.protocols.adapters.adapter import AdapterRegistry
-from lionagi.protocols.adapters.json_adapter import (
-    JsonAdapter,
-    JsonFileAdapter,
-)
-from lionagi.protocols.adapters.pandas_adapter import PandasSeriesAdapter
-
-ADAPTERS = [
-    JsonAdapter,
-    JsonFileAdapter,
-    PandasSeriesAdapter,
-]
-
-
-class ComponentAdapterRegistry(AdapterRegistry):
-    _adapters = {k.obj_key: k() for k in ADAPTERS}
-
-
-__all__ = ["ComponentAdapterRegistry"]

lionagi/protocols/registries/_pile_registry.py

@@ -1,30 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from lionagi.protocols.adapters.adapter import AdapterRegistry
-from lionagi.protocols.adapters.json_adapter import (
-    JsonAdapter,
-    JsonFileAdapter,
-)
-from lionagi.protocols.adapters.pandas_adapter import (
-    CSVFileAdapter,
-    ExcelFileAdapter,
-    PandasDataFrameAdapter,
-)
-
-ADAPTERS = [
-    JsonAdapter,
-    JsonFileAdapter,
-    PandasDataFrameAdapter,
-    CSVFileAdapter,
-    ExcelFileAdapter,
-]
-
-
-class PileAdapterRegistry(AdapterRegistry):
-
-    _adapters = {k.obj_key: k() for k in ADAPTERS}
-
-
-__all__ = ["PileAdapterRegistry"]

lionagi/service/complete_request_info.py

@@ -1,11 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class CompleteRequestInfo(BaseModel):
-    timestamp: float = Field(description="HTTP response generated time")
-
-
-class CompleteRequestTokenInfo(CompleteRequestInfo):
-    token_usage: int = Field(
-        description="Number of tokens used in the request"
-    )