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

lionagi/service/rate_limiter.py

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

@@ -0,0 +1,37 @@
+class Service:
+
+    def list_tasks(self):
+        pass
+
+
+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

lionagi/service/service_match_util.py

@@ -0,0 +1,131 @@
+import inspect
+import re
+import warnings
+from os import getenv
+
+from .service import ServiceSetting
+
+imported_services = {}
+
+
+def match_service(service_name: str, **kwargs):
+    service_name = service_name.lower()
+
+    def check_key_match(key1, key2):
+        if key1 is not None:
+            key1 = getenv(key1) if getenv(key1) else key1
+        if key2 is not None:
+            key2 = getenv(key2) if getenv(key2) else key2
+        return key1 == key2
+
+    if service_name == "openai":
+        from lionagi.integrations.services import OpenAIService
+
+        api_key = kwargs.get("api_key")
+        openai_organization = kwargs.get("openai_organization")
+        openai_project = kwargs.get("openai_project")
+
+        for service in ServiceSetting.services.values():
+            if isinstance(service, OpenAIService):
+                if (
+                    check_key_match(service.api_key, api_key)
+                    and check_key_match(
+                        service.openai_organization, openai_organization
+                    )
+                    and check_key_match(service.openai_project, openai_project)
+                ):
+                    return service
+
+        # when no matching
+        return OpenAIService(
+            api_key=api_key,
+            openai_organization=openai_organization,
+            openai_project=openai_project,
+        )
+
+    elif service_name == "anthropic":
+        from lionagi.integrations.services import AnthropicService
+
+        api_key = kwargs.get("api_key")
+        api_version = kwargs.get("api_version", "2023-06-01")
+
+        for service in ServiceSetting.services.values():
+            if isinstance(service, AnthropicService):
+                if check_key_match(
+                    service.api_key, api_key
+                ) and check_key_match(service.api_version, api_version):
+                    return service
+
+        # when no matching
+        return AnthropicService(
+            api_key=api_key,
+            api_version=api_version,
+        )
+
+    elif service_name == "perplexity":
+        from lionagi.integrations.services import PerplexityService
+
+        api_key = kwargs.get("api_key")
+        api_version = kwargs.get("api_version", "2023-06-01")
+
+        for service in ServiceSetting.services.values():
+            if isinstance(service, PerplexityService):
+                if check_key_match(service.api_key, api_key):
+                    return service
+
+        # when no matching
+        return PerplexityService(api_key=api_key)
+
+    elif service_name == "groq":
+        from lionagi.integrations.services import GroqService
+
+        api_key = kwargs.get("api_key")
+        for service in ServiceSetting.services.values():
+            if isinstance(service, GroqService):
+                if check_key_match(service.api_key, api_key):
+                    return service
+
+        # when no matching
+        return GroqService(api_key=api_key)
+
+    raise ValueError(f"Service {service_name} is not available")
+
+
+def match_task_method(task_name, service_obj):
+    def clean_name(name):
+        return re.sub(r"[^a-zA-Z0-9]", "", name).lower()
+
+    task_name = clean_name(task_name)
+    if task_name.endswith("s"):
+        task_name = task_name[:-1]
+    methods = [
+        method_name
+        for method_name in dir(service_obj)
+        if task_name in clean_name(method_name)
+    ]
+    return methods
+
+
+def match_parameters(method, model, interval_tokens, interval_requests):
+    method_params = inspect.signature(method).parameters
+    kwargs = {}
+    if "model" in method_params:
+        kwargs["model"] = model
+    if "limit_requests" in method_params:
+        kwargs["limit_requests"] = interval_requests
+    else:
+        # no limit_requests but interval_requests provided
+        if interval_requests is not None:
+            warnings.warn(
+                f"The system does not support tracking limit requests per minute for {method.__name__}"
+            )
+    if "limit_tokens" in method_params:
+        kwargs["limit_tokens"] = interval_tokens
+    else:
+        # no limit_tokens but interval_tokens provided
+        if interval_tokens is not None:
+            warnings.warn(
+                f"The system does not support tracking limit tokens per minute for {method.__name__}"
+            )
+
+    return kwargs

lionagi/service/service_util.py

@@ -0,0 +1,72 @@
+import asyncio
+from functools import wraps
+
+from .rate_limiter import RateLimitError
+
+
+def invoke_retry(
+    max_retries: int = 3, base_delay: int = 1, max_delay: int = 60
+):
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(request_model, *args, **kwargs):
+            if max_retries <= 0:
+                raise ValueError(
+                    "Invalid max number of retries. It must a positive integer."
+                )
+
+            for retry in range(max_retries + 1):
+                try:
+                    response_body = await func(request_model, *args, **kwargs)
+                    return response_body
+                except Exception as e:
+                    # Last try used
+                    if retry == max_retries:
+                        raise e
+
+                    # RateLimitError for Model only
+                    if isinstance(e, RateLimitError):
+                        if (
+                            e.requested_tokens
+                            > request_model.rate_limiter.limit_tokens
+                        ):
+                            raise ValueError(
+                                "Requested tokens exceed the model's token limit. "
+                                "Please modify the input, adjust the expected output tokens, or increase the token limit. "
+                                f"The current token limit is {request_model.rate_limiter.limit_tokens} tokens."
+                            )
+
+                        while request_model.rate_limiter.unreleased_requests:
+                            await asyncio.sleep(2)
+                            request_model.rate_limiter.release_tokens()
+                            if request_model.rate_limiter.check_availability(
+                                request_token_len=e.requested_tokens
+                            ):
+                                break
+
+                    elif error_code := getattr(
+                        e, "status", None
+                    ):  # http request errors
+                        if (
+                            error_code == 429
+                            and "exceeded your current quota" in str(e)
+                        ):  # RateLimitError (account quota reached)
+                            raise e
+                        if (
+                            error_code == 429 or error_code >= 500
+                        ):  # ServerError
+                            if retry_after := getattr(e, "headers", {}).get(
+                                "Retry-After"
+                            ):
+                                if retry_after.isdigit():
+                                    await asyncio.sleep(int(retry_after))
+                                    continue
+
+                            wait_time = min(base_delay * (2**retry), max_delay)
+                            await asyncio.sleep(wait_time)
+                    else:
+                        raise e
+
+        return wrapper
+
+    return decorator

lionagi/service/token_calculator.py

@@ -0,0 +1,51 @@
+from abc import abstractmethod
+
+import tiktoken
+from pydantic import BaseModel, Field, field_validator
+
+
+class TokenCalculator(BaseModel):
+
+    @abstractmethod
+    def calculate(self, *args, **kwargs): ...
+
+
+class TiktokenCalculator(TokenCalculator):
+    encoding_name: str = Field(
+        description="Encoding for converting text to tokens. "
+        "Input encoding name or a specific OpenAI model",
+        examples=["o200k_base", "gpt-4o"],
+    )
+
+    @field_validator("encoding_name")
+    @classmethod
+    def get_encoding_name(cls, value: str) -> str:
+        try:
+            enc = tiktoken.encoding_for_model(value)
+            return enc.name
+        except:
+            try:
+                tiktoken.get_encoding(value)
+                return value
+            except:
+                return "o200k_base"
+
+    def encode(self, text: str) -> list[int]:
+        enc = tiktoken.get_encoding(self.encoding_name)
+        return enc.encode(text=text)
+
+    def calculate(self, text: str) -> int:
+        enc_text = self.encode(text)
+        return len(enc_text)
+
+    def tokenize(
+        self, text: str, decode_byte_str: bool = False, decoder: str = "utf-8"
+    ):
+        enc = tiktoken.get_encoding(self.encoding_name)
+        enc_text = self.encode(text)
+        tokens = [
+            enc.decode_single_token_bytes(token_id) for token_id in enc_text
+        ]
+        if decode_byte_str:
+            tokens = [token.decode(decoder) for token in tokens]
+        return tokens

lionagi/settings.py

@@ -0,0 +1,136 @@
+from datetime import timezone
+from enum import Enum
+
+from lionagi.protocols.configs import (
+    BranchConfig,
+    LionIDConfig,
+    MessageConfig,
+    RetryConfig,
+    TimedFuncCallConfig,
+    iModelConfig,
+)
+from lionagi.protocols.configs.log_config import LogConfig
+
+
+class BaseSystemFields(str, Enum):
+    ln_id = "ln_id"
+    TIMESTAMP = "timestamp"
+    METADATA = "metadata"
+    EXTRA_FIELDS = "extra_fields"
+    CONTENT = "content"
+    CREATED = "created"
+    EMBEDDING = "embedding"
+
+
+DEFAULT_ID_CONFIG = LionIDConfig(
+    n=36,
+    random_hyphen=True,
+    num_hyphens=4,
+    hyphen_start_index=6,
+    hyphen_end_index=-6,
+    prefix="ao",
+    postfix="",
+)
+
+DEFAULT_TIMED_FUNC_CALL_CONFIG = TimedFuncCallConfig(
+    initial_delay=0,
+    retry_timeout=None,
+    retry_timing=False,
+    error_msg=None,
+    error_map=None,
+)
+
+DEFAULT_RETRY_CONFIG = RetryConfig(
+    num_retries=0,
+    initial_delay=0,
+    retry_delay=0,
+    backoff_factor=1,
+    retry_timeout=None,
+    retry_timing=False,
+    verbose_retry=False,
+    error_msg=None,
+    error_map=None,
+)
+
+
+DEFAULT_CHAT_CONFIG = iModelConfig(
+    provider="openai",
+    task="chat",
+    model="gpt-4o",
+    api_key="OPENAI_API_KEY",
+)
+
+
+DEFAULT_RETRY_iMODEL_CONFIG = iModelConfig(
+    provider="openai",
+    task="chat",
+    model="gpt-4o-mini",
+    api_key="OPENAI_API_KEY",
+)
+
+
+DEFAULT_MESSAGE_CONFIG = MessageConfig(
+    validation_mode="raise",
+    auto_retries=False,
+    max_retries=0,
+    allow_actions=True,
+    auto_invoke_action=True,
+)
+
+
+DEFAULT_MESSAGE_LOG_CONFIG = LogConfig(
+    persist_dir="./data/logs",
+    subfolder="messages",
+    file_prefix="message_",
+    capacity=128,
+    auto_save_on_exit=True,
+    clear_after_dump=True,
+    use_timestamp=True,
+    extension=".csv",
+)
+
+DEFAULT_ACTION_LOG_CONFIG = LogConfig(
+    persist_dir="./data/logs",
+    subfolder="actions",
+    file_prefix="action_",
+    capacity=128,
+    auto_save_on_exit=True,
+    clear_after_dump=True,
+    use_timestamp=True,
+    extension=".csv",
+)
+
+DEFAULT_BRANCH_CONFIG = BranchConfig(
+    name=None,
+    user=None,
+    message_log_config=DEFAULT_MESSAGE_LOG_CONFIG,
+    action_log_config=DEFAULT_ACTION_LOG_CONFIG,
+    message_config=DEFAULT_MESSAGE_CONFIG,
+    auto_register_tools=True,
+    action_call_config=DEFAULT_TIMED_FUNC_CALL_CONFIG,
+    imodel_config=DEFAULT_CHAT_CONFIG,
+    retry_imodel_config=DEFAULT_RETRY_iMODEL_CONFIG,
+)
+
+
+DEFAULT_TIMEZONE = timezone.utc
+BASE_LION_FIELDS = set(BaseSystemFields.__members__.values())
+
+
+class Settings:
+
+    class Config:
+        ID: LionIDConfig = DEFAULT_ID_CONFIG
+        RETRY: RetryConfig = DEFAULT_RETRY_CONFIG
+        TIMED_CALL: TimedFuncCallConfig = DEFAULT_TIMED_FUNC_CALL_CONFIG
+        TIMEZONE: timezone = DEFAULT_TIMEZONE
+
+    class Branch:
+        BRANCH: BranchConfig = DEFAULT_BRANCH_CONFIG
+
+    class iModel:
+        CHAT: dict = {"model": "openai/gpt-4o"}
+        PARSE: iModelConfig = DEFAULT_CHAT_CONFIG
+
+
+# File: autoos/setting.py

lionagi/strategies/base.py

@@ -0,0 +1,53 @@
+from typing import ClassVar
+
+from pydantic import model_validator
+
+from lionagi.fields.instruct import Instruct, InstructResponse
+
+from ..protocols.types import BaseLionModel
+from ..session.types import Branch, Session
+from .params import StrategyParams
+
+
+class StrategyExecutor(BaseLionModel):
+    """Base class for different execution strategies.
+
+    Each concrete executor should implement `execute()` to run instructions
+    according to a specific strategy (e.g., sequential, concurrent, chunked).
+    """
+
+    session: Session = None
+    branch: Branch = None
+    execute_branch: Branch = None
+    params: StrategyParams = None
+    params_cls: ClassVar[type[StrategyParams]] = StrategyParams
+
+    @model_validator(mode="before")
+    def validate_execution_config(cls, values: dict) -> dict:
+        params_cls = values.get("params_cls", cls.params_cls)
+        params = values.get("params", None)
+
+        if isinstance(params, dict):
+            params = params_cls(**params)
+        if not isinstance(params, StrategyParams):
+            params = params_cls(**values)
+
+        session: Session = values.get("session", params.session)
+        branch = values.get("branch", params.branch)
+        execute_branch = values.get("execute_branch", None) or session.split(
+            branch
+        )
+
+        return {
+            "params": params,
+            "session": session,
+            "branch": branch,
+            "execute_branch": execute_branch,
+            "params_cls": params_cls,
+        }
+
+    async def execute(
+        self, res
+    ) -> tuple[list[Instruct], list[InstructResponse]]:
+        """Run the instructions based on the strategy implemented by subclasses."""
+        raise NotImplementedError

lionagi/strategies/concurrent.py

@@ -0,0 +1,71 @@
+from lionagi.fields.instruct import Instruct, InstructResponse
+from lionagi.session.types import Branch
+from lionagi.utils import alcall, to_list
+
+from .base import StrategyExecutor
+
+
+class ConcurrentExecutor(StrategyExecutor):
+    """Executor for concurrent instruction processing.
+
+    Runs each instruction in parallel without chunking.
+    """
+
+    async def execute_instruct(
+        self, ins: Instruct, branch: Branch, auto_run: bool, **kwargs
+    ):
+        async def run(ins_):
+            if self.params.verbose:
+                print(f"\n-----Running sub-instruction-----\n{ins_.msg}")
+            b_ = self.session.split(branch)
+            return await self.execute_instruct(ins_, b_, False, **kwargs)
+
+        config = {**ins.model_dump(), **kwargs}
+        res = await branch.instruct(**config)
+        branch.msgs.logger.dump()
+        instructs = (
+            res.instruct_models if hasattr(res, "instruct_models") else []
+        )
+
+        if auto_run and instructs:
+            ress = await alcall(instructs, run)
+            response_ = []
+            for r in ress:
+                if isinstance(r, list):
+                    response_.extend(r)
+                else:
+                    response_.append(r)
+            response_.insert(0, res)
+            return response_
+        return res
+
+    async def instruct_concurrent_single(
+        self, ins_: Instruct, execute_branch: Branch
+    ) -> InstructResponse:
+        if self.params.verbose:
+            print(f"\n-----Running instruction-----\n{ins_.msg}")
+        b_ = self.session.split(execute_branch)
+        response = await self.execute_instruct(
+            ins_, b_, self.params.auto_run, **self.params.execute_kwargs
+        )
+        return InstructResponse(instruct=ins_, response=response)
+
+    async def execute(
+        self, res
+    ) -> tuple[list[Instruct], list[InstructResponse]]:
+        async with self.session.branches:
+            response_ = []
+            instructs = []
+            if hasattr(res, "instruct_models"):
+                instructs: list[Instruct] = res.instruct_models
+                ress = await alcall(
+                    instructs,
+                    self.instruct_concurrent_single,
+                    execute_branch=self.execute_branch,
+                )
+                ress = to_list(ress, dropna=True, flatten=True)
+                response_ = [r for r in ress if not isinstance(r, (str, dict))]
+                response_ = to_list(
+                    response_, unique=True, dropna=True, flatten=True
+                )
+            return instructs, response_