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

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

lionagi/service/service_match_util.py

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

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

@@ -1,51 +0,0 @@
-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/strategies/types.py

@@ -1,21 +0,0 @@
-from .base import StrategyExecutor
-from .concurrent import ConcurrentExecutor
-from .concurrent_chunk import ConcurrentChunkExecutor
-from .concurrent_sequential_chunk import ConcurrentSequentialChunkExecutor
-from .params import ChunkStrategyParams, HybridStrategyParams, StrategyParams
-from .sequential import SequentialExecutor
-from .sequential_chunk import SequentialChunkExecutor
-from .sequential_concurrent_chunk import SequentialConcurrentChunkExecutor
-
-__all__ = (
-    "StrategyExecutor",
-    "ConcurrentExecutor",
-    "ConcurrentSequentialChunkExecutor",
-    "ConcurrentChunkExecutor",
-    "SequentialConcurrentChunkExecutor",
-    "SequentialExecutor",
-    "SequentialChunkExecutor",
-    "StrategyParams",
-    "ChunkStrategyParams",
-    "HybridStrategyParams",
-)