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

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"
-    )

lionagi/service/rate_limiter.py

@@ -1,108 +0,0 @@
-from collections import deque
-from datetime import UTC, datetime, timezone
-
-from pydantic import BaseModel, Field
-
-from .complete_request_info import (
-    CompleteRequestInfo,
-    CompleteRequestTokenInfo,
-)
-
-
-class RateLimiter(BaseModel):
-    limit_tokens: int = Field(default=None)
-
-    limit_requests: int = Field(default=None)
-
-    remaining_tokens: int = Field(default=None)
-
-    remaining_requests: int = Field(default=None)
-
-    last_check_timestamp: float = Field(
-        default=None, description="Last time to check tokens and requests."
-    )
-
-    unreleased_requests: deque = Field(
-        default_factory=deque,
-        description="completed request info for replenish",
-        exclude=True,
-    )
-
-    def append_complete_request_token_info(self, info: CompleteRequestInfo):
-        if not self.limit_tokens and not self.limit_requests:
-            # no limits
-            return
-
-        self.unreleased_requests.append(info)
-        if self.limit_tokens and isinstance(info, CompleteRequestTokenInfo):
-            # For request with token limits only
-            if self.remaining_tokens:
-                self.remaining_tokens -= info.token_usage
-            else:
-                self.remaining_tokens = self.limit_tokens - info.token_usage
-
-        if self.limit_requests:
-            if self.remaining_requests:
-                self.remaining_requests -= 1
-            else:
-                self.remaining_requests = self.limit_requests - 1
-
-    def release_tokens(self):
-        self.last_check_timestamp = datetime.now(UTC).timestamp()
-        while self.unreleased_requests:
-            if (
-                datetime.now(UTC).timestamp()
-                - self.unreleased_requests[0].timestamp
-                > 60
-            ):
-                release_info = self.unreleased_requests.popleft()
-                if (
-                    isinstance(release_info, CompleteRequestTokenInfo)
-                    and self.remaining_tokens
-                ):
-                    self.remaining_tokens += release_info.token_usage
-                if self.remaining_requests:
-                    self.remaining_requests += 1
-            else:
-                break
-
-    def update_rate_limit(
-        self, request_datetime_header, total_token_usage: int = None
-    ):
-        # rate limiter tokens only tracks if there are token usage info
-        # otherwise, tracks requests num
-        date_format = "%a, %d %b %Y %H:%M:%S GMT"  # the format of the date string according to RFC 1123
-        # (in http response header)
-        dt = datetime.strptime(request_datetime_header, date_format)
-        dt = dt.replace(tzinfo=timezone.utc)
-        request_timestamp = dt.timestamp()
-
-        if total_token_usage:
-            complete_request_info = CompleteRequestTokenInfo(
-                timestamp=request_timestamp, token_usage=total_token_usage
-            )
-        else:
-            complete_request_info = CompleteRequestInfo(
-                timestamp=request_timestamp
-            )
-        self.append_complete_request_token_info(complete_request_info)
-
-    def check_availability(
-        self, request_token_len: int = 0, estimated_output_len: int = 0
-    ):
-        if self.remaining_tokens is not None:
-            if (
-                request_token_len + estimated_output_len
-                > self.remaining_tokens
-            ):
-                return False
-        if self.remaining_requests is not None:
-            if self.remaining_requests <= 0:
-                return False
-        return True
-
-
-class RateLimitError(Exception):
-    def __init__(self, message, input_token_len, estimated_output_len):
-        super().__init__(message)
-        self.requested_tokens = input_token_len + estimated_output_len

lionagi/service/service.py

@@ -1,41 +0,0 @@
-class Service:
-
-    def list_tasks(self):
-        pass
-
-    @property
-    def allowed_roles(self):
-        return ["user", "assistant", "system"]
-
-
-def register_service(cls):
-    original_init = cls.__init__
-
-    def wrapped_init(self, *args, **kwargs):
-        original_init(self, *args, **kwargs)
-        service_name = self.name
-        ServiceSetting().add_service(self, service_name)
-
-    cls.__init__ = wrapped_init
-    return cls
-
-
-class ServiceSetting:
-    _instance = None
-    services = {}
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-
-    def add_service(self, service: Service, name: str = None):
-        if name:
-            if self.services.get(name):
-                raise ValueError(
-                    "Invalid name. There is a service using the name, please change a name."
-                )
-            self.services[name] = service
-        else:
-            name = service.__class__.__name__ + "_" + str(len(self.services))
-            self.services[name] = service