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

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