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

lionagi/core/typing/id.py

@@ -0,0 +1,221 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from lionagi.libs.utils import insert_random_hyphens, unique_hash
+from lionagi.settings import LionIDConfig, Settings
+
+from .concepts import Container, Generic, ItemError, Observable, Ordering, T
+from .pydantic_ import Field
+from .typing_ import Annotated, Container, Mapping, Sequence, TypeAlias
+
+LnID: TypeAlias = Annotated[str, Field(description="A unique identifier.")]
+
+
+class IDError(ItemError):
+    """Exception raised when an item does not have a Lion ID."""
+
+    def __init__(
+        self,
+        message: str = "Item must contain a Lion ID.",
+        item_id: str | None = None,
+    ):
+        super().__init__(message, item_id)
+
+
+class ID(Generic[T]):
+    """
+    A generic class that provides ID-related functionality for Observable objects.
+
+    This class handles the generation, validation, and management of unique identifiers
+    within the Lion system. It provides type aliases for various ID-related operations
+    and methods for working with IDs.
+    """
+
+    # For functions that accept either ID or item
+    Ref: TypeAlias = LnID | T  # type: ignore
+
+    # For functions requiring just the ID
+    ID: TypeAlias = LnID
+
+    # For functions requiring Observable object
+    Item = T  # type: ignore
+
+    # For collections
+    IDSeq: TypeAlias = Sequence[LnID] | Ordering[LnID]
+    ItemSeq: TypeAlias = (  # type: ignore
+        Sequence[T] | Mapping[LnID, T] | Container[LnID | T]
+    )
+    RefSeq: TypeAlias = IDSeq | ItemSeq
+
+    # For system-level interactions
+    SenderRecipient: TypeAlias = LnID | T  # type: ignore
+
+    @staticmethod
+    def id(
+        config: LionIDConfig = Settings.Config.ID,
+        n: int = None,
+        prefix: str = None,
+        postfix: str = None,
+        random_hyphen: bool = None,
+        num_hyphens: int = None,
+        hyphen_start_index: int = None,
+        hyphen_end_index: int = None,
+    ) -> LnID:
+        """
+        Generate a unique identifier.
+
+        Args:
+            n: Length of the ID (excluding prefix and postfix).
+            prefix: String to prepend to the ID.
+            postfix: String to append to the ID.
+            random_hyphen: If True, insert random hyphens into the ID.
+            num_hyphens: Number of hyphens to insert if random_hyphen is True.
+            hyphen_start_index: Start index for hyphen insertion.
+            hyphen_end_index: End index for hyphen insertion.
+
+        Returns:
+            A unique identifier string.
+        """
+        _dict = {
+            "n": n,
+            "prefix": prefix,
+            "postfix": postfix,
+            "random_hyphen": random_hyphen,
+            "num_hyphens": num_hyphens,
+            "hyphen_start_index": hyphen_start_index,
+            "hyphen_end_index": hyphen_end_index,
+        }
+        _dict = {k: v for k, v in _dict.items() if v is not None}
+        config = {**config.to_dict(), **_dict}
+        return ID._id(**config)
+
+    @staticmethod
+    def _id(
+        *,
+        n: int,
+        prefix: str = "",
+        postfix: str = "",
+        random_hyphen: bool = False,
+        num_hyphens: int = 0,
+        hyphen_start_index: int = 6,
+        hyphen_end_index: int = -6,
+    ):
+        _id = unique_hash(n)
+        if random_hyphen:
+            _id = insert_random_hyphens(
+                s=_id,
+                num_hyphens=num_hyphens,
+                start_index=hyphen_start_index,
+                end_index=hyphen_end_index,
+            )
+        if prefix:
+            _id = f"{prefix}{_id}"
+        if postfix:
+            _id = f"{_id}{postfix}"
+
+        return _id
+
+    @staticmethod
+    def get_id(
+        item,
+        config: LionIDConfig = Settings.Config.ID,
+        /,
+    ) -> str:
+        """
+        Get the Lion ID of an item.
+
+        Args:
+            item: The item to get the ID from.
+            config: Configuration dictionary for ID validation.
+
+        Returns:
+            The Lion ID of the item.
+
+        Raises:
+            LionIDError: If the item does not contain a valid Lion ID.
+        """
+
+        item_id = None
+        if isinstance(item, Sequence) and len(item) == 1:
+            item = item[0]
+
+        if isinstance(item, Observable):
+            item_id: str = item.ln_id
+        else:
+            item_id = item
+
+        check = isinstance(item_id, str)
+        if check:
+            id_len = (
+                (len(config.prefix) if config.prefix else 0)
+                + config.n
+                + config.num_hyphens
+                + (len(config.postfix) if config.postfix else 0)
+            )
+            if len(item_id) != id_len:
+                check = False
+        if check and config.prefix:
+            if item_id.startswith(config.prefix):
+                item_id = item_id[len(config.prefix) :]  # noqa
+            else:
+                check = False
+        if check and config.postfix:
+            if item_id.endswith(config.postfix):
+                item_id = item_id[: -len(config.postfix)]
+            else:
+                check = False
+        if check and config.num_hyphens:
+            if config.num_hyphens != item_id.count("-"):
+                check = False
+        if check and config.hyphen_start_index:
+            idx = config.hyphen_start_index - len(config.prefix)
+            if idx > 0 and "-" in item_id[:idx]:
+                check = False
+        if check and config.hyphen_end_index:
+            if config.hyphen_end_index < 0:
+                idx = config.hyphen_end_index + id_len
+            idx -= len(config.prefix + config.postfix)
+            if idx < 0 and "-" in item_id[idx:]:
+                check = False
+
+        if check:
+            return config.prefix + item_id + config.postfix
+        if (
+            isinstance(item_id, str) and len(item_id) == 32
+        ):  # for backward compatibility
+            return item_id
+        raise IDError(
+            f"The input object of type <{type(item).__name__}> does "
+            "not contain or is not a valid Lion ID. Item must be an instance"
+            " of `Observable` or a valid `ln_id`."
+        )
+
+    @staticmethod
+    def is_id(
+        item,
+        config: LionIDConfig = Settings.Config.ID,
+        /,
+    ) -> bool:
+        """
+        Check if an item is a valid Lion ID.
+
+        Args:
+            item: The item to check.
+            config: Configuration dictionary for ID validation.
+
+        Returns:
+            True if the item is a valid Lion ID, False otherwise.
+        """
+        try:
+            ID.get_id(item, config)
+            return True
+        except IDError:
+            return False
+
+
+__all__ = [
+    "LnID",
+    "ID",
+    "IDError",
+]

lionagi/core/typing/pydantic_.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    JsonValue,
+    PrivateAttr,
+    create_model,
+    field_serializer,
+    field_validator,
+    model_serializer,
+    model_validator,
+)
+from pydantic.fields import FieldInfo
+from pydantic_core import PydanticUndefined
+
+__all__ = [
+    "BaseModel",
+    "ConfigDict",
+    "Field",
+    "JsonValue",
+    "PrivateAttr",
+    "FieldInfo",
+    "PydanticUndefined",
+    "field_validator",
+    "model_validator",
+    "model_serializer",
+    "field_serializer",
+    "create_model",
+]

lionagi/core/typing/typing_.py

@@ -0,0 +1,54 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC
+from collections.abc import (
+    Callable,
+    Container,
+    ItemsView,
+    Iterator,
+    Mapping,
+    Sequence,
+    ValuesView,
+)
+from enum import Enum
+from typing import (
+    Annotated,
+    Any,
+    ClassVar,
+    Generic,
+    Literal,
+    NoReturn,
+    Self,
+    TypeAlias,
+    TypeVar,
+)
+
+from typing_extensions import override
+
+from lionagi.libs.constants import UNDEFINED, UndefinedType
+
+__all__ = [
+    "ABC",
+    "Annotated",
+    "Any",
+    "ClassVar",
+    "Container",
+    "Enum",
+    "Generic",
+    "Literal",
+    "Mapping",
+    "NoReturn",
+    "Sequence",
+    "TypeAlias",
+    "TypeVar",
+    "UndefinedType",
+    "UNDEFINED",
+    "override",
+    "Callable",
+    "Self",
+    "Iterator",
+    "ValuesView",
+    "ItemsView",
+]

lionagi/integrations/__init__.py

@@ -1 +0,0 @@
-from . import *

lionagi/integrations/anthropic_/AnthropicModel.py

@@ -0,0 +1,268 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+
+import yaml
+from dotenv import load_dotenv
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_serializer,
+    model_validator,
+)
+
+from lionagi.integrations.anthropic_.api_endpoints.api_request import (
+    AnthropicRequest,
+)
+from lionagi.integrations.anthropic_.api_endpoints.match_response import (
+    match_response,
+)
+from lionagi.integrations.anthropic_.api_endpoints.messages.request.request_body import (
+    AnthropicMessageRequestBody,
+)
+from lionagi.service.rate_limiter import RateLimiter, RateLimitError
+from lionagi.service.service_util import invoke_retry
+from lionagi.service.token_calculator import TiktokenCalculator
+
+load_dotenv()
+path = Path(__file__).parent
+
+price_config_file_name = path / "anthropic_price_data.yaml"
+max_output_token_file_name = path / "anthropic_max_output_token_data.yaml"
+
+
+class AnthropicModel(BaseModel):
+    model: str = Field(description="ID of the model to use.")
+
+    request_model: AnthropicRequest = Field(description="Making requests")
+
+    rate_limiter: RateLimiter = Field(
+        description="Rate Limiter to track usage"
+    )
+
+    text_token_calculator: TiktokenCalculator = Field(
+        default=None, description="Token Calculator"
+    )
+
+    estimated_output_len: int = Field(
+        default=0, description="Expected output len before making request"
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_input(cls, data: dict):
+        if not isinstance(data, dict):
+            raise ValueError("Invalid init param")
+
+        # parse request model
+        request_model_params = {
+            "api_key": data.pop("api_key", None),
+            "endpoint": data.pop("endpoint", None),
+            "method": data.pop("method", None),
+            "content_type": data.pop("content_type", None),
+            "api_version": data.pop("api_version", None),
+        }
+        data["request_model"] = AnthropicRequest(**request_model_params)
+
+        # parse rate limiter
+        if "rate_limiter" not in data:
+            rate_limiter_params = {}
+            if limit_tokens := data.pop("limit_tokens", None):
+                rate_limiter_params["limit_tokens"] = limit_tokens
+            if limit_requests := data.pop("limit_requests", None):
+                rate_limiter_params["limit_requests"] = limit_requests
+
+            data["rate_limiter"] = RateLimiter(**rate_limiter_params)
+
+        # parse token calculator
+        try:
+            # Anthropic uses cl100k_base encoding
+            text_calc = TiktokenCalculator(encoding_name="cl100k_base")
+            data["text_token_calculator"] = text_calc
+        except Exception:
+            pass
+
+        return data
+
+    @field_serializer("request_model")
+    def serialize_request_model(self, value: AnthropicRequest):
+        return value.model_dump(exclude_unset=True)
+
+    @invoke_retry(max_retries=3, base_delay=1, max_delay=60)
+    async def invoke(
+        self,
+        request_body: AnthropicMessageRequestBody,
+        estimated_output_len: int = 0,
+        output_file=None,
+        parse_response=True,
+    ):
+        if request_model := getattr(request_body, "model"):
+            if request_model != self.model:
+                raise ValueError(
+                    f"Request model does not match. Model is {self.model}, but request is made for {request_model}."
+                )
+
+        # check remaining rate limit
+        input_token_len = await self.get_input_token_len(request_body)
+
+        if getattr(request_body, "max_tokens", None):
+            estimated_output_len = request_body.max_tokens
+
+        invoke_viability_result = self.verify_invoke_viability(
+            input_tokens_len=input_token_len,
+            estimated_output_len=estimated_output_len,
+        )
+        if not invoke_viability_result:
+            raise RateLimitError("Rate limit reached for requests")
+
+        try:
+            if getattr(request_body, "stream", None):
+                return await self.stream(
+                    request_body,
+                    output_file=output_file,
+                    parse_response=parse_response,
+                )
+
+            response_body, response_headers = await self.request_model.invoke(
+                json_data=request_body,
+                output_file=output_file,
+                with_response_header=True,
+                parse_response=False,
+            )
+
+            if response_body:
+                # Update rate limit based on usage
+                if response_body.get("usage"):
+                    total_token_usage = (
+                        response_body["usage"]["input_tokens"]
+                        + response_body["usage"]["output_tokens"]
+                    )
+                    self.rate_limiter.update_rate_limit(
+                        response_headers.get("Date"), total_token_usage
+                    )
+                else:
+                    self.rate_limiter.update_rate_limit(
+                        response_headers.get("Date")
+                    )
+
+            if parse_response:
+                return match_response(self.request_model, response_body)
+            else:
+                return response_body
+
+        except Exception as e:
+            raise e
+
+    async def stream(
+        self,
+        request_body: AnthropicMessageRequestBody,
+        output_file=None,
+        parse_response=True,
+        verbose=True,
+    ):
+        response_chunks = []
+        response_headers = None
+
+        async for chunk in self.request_model.stream(
+            json_data=request_body,
+            output_file=output_file,
+            with_response_header=True,
+            verbose=verbose,
+        ):
+            if isinstance(chunk, dict):
+                if chunk.get("type") in [
+                    "content_block_delta",
+                    "message_delta",
+                    "message_stop",
+                ]:
+                    response_chunks.append(chunk)
+                elif "headers" in chunk:
+                    response_headers = chunk["headers"]
+
+        # Update rate limit if we have usage information
+        if response_chunks and response_chunks[-1].get("usage"):
+            total_token_usage = (
+                response_chunks[-1]["usage"]["input_tokens"]
+                + response_chunks[-1]["usage"]["output_tokens"]
+            )
+            if response_headers:
+                self.rate_limiter.update_rate_limit(
+                    response_headers.get("Date"), total_token_usage
+                )
+
+        if parse_response:
+            return match_response(self.request_model, response_chunks)
+        else:
+            return response_chunks
+
+    async def get_input_token_len(
+        self, request_body: AnthropicMessageRequestBody
+    ):
+        if request_model := getattr(request_body, "model"):
+            if request_model != self.model:
+                raise ValueError(
+                    f"Request model does not match. Model is {self.model}, but request is made for {request_model}."
+                )
+
+        total_tokens = 0
+        for message in request_body.messages:
+            total_tokens += self.text_token_calculator.calculate(
+                message.content
+            )
+
+        if request_body.system:
+            total_tokens += self.text_token_calculator.calculate(
+                request_body.system
+            )
+
+        return total_tokens
+
+    def verify_invoke_viability(
+        self, input_tokens_len: int = 0, estimated_output_len: int = 0
+    ):
+        self.rate_limiter.release_tokens()
+
+        estimated_output_len = (
+            estimated_output_len
+            if estimated_output_len != 0
+            else self.estimated_output_len
+        )
+        if estimated_output_len == 0:
+            with open(max_output_token_file_name) as file:
+                output_token_config = yaml.safe_load(file)
+                estimated_output_len = output_token_config.get(self.model, 0)
+                self.estimated_output_len = estimated_output_len
+
+        if self.rate_limiter.check_availability(
+            input_tokens_len, estimated_output_len
+        ):
+            return True
+        else:
+            return False
+
+    def estimate_text_price(
+        self,
+        input_text: str,
+        estimated_num_of_output_tokens: int = 0,
+    ):
+        if self.text_token_calculator is None:
+            raise ValueError("Token calculator not available")
+
+        num_of_input_tokens = self.text_token_calculator.calculate(input_text)
+
+        with open(price_config_file_name) as file:
+            price_config = yaml.safe_load(file)
+
+        model_price_info_dict = price_config["model"][self.model]
+        estimated_price = (
+            model_price_info_dict["input_tokens"] * num_of_input_tokens
+            + model_price_info_dict["output_tokens"]
+            * estimated_num_of_output_tokens
+        )
+
+        return estimated_price

lionagi/integrations/anthropic_/AnthropicService.py

@@ -0,0 +1,113 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import inspect
+
+from dotenv import load_dotenv
+
+from lionagi.integrations.anthropic_.api_endpoints.messages.request.request_body import (
+    AnthropicMessageRequestBody,
+)
+from lionagi.service import Service, register_service
+
+from .AnthropicModel import AnthropicModel
+
+load_dotenv()
+
+
+@register_service
+class AnthropicService(Service):
+    def __init__(
+        self,
+        api_key: str,
+        api_version: str = "2023-06-01",
+        name: str = None,
+    ):
+        super().__setattr__("_initialized", False)
+        self.api_key = api_key
+        self.api_version = api_version
+        self.name = name
+        self.rate_limiters = {}  # model: RateLimiter
+        super().__setattr__("_initialized", True)
+
+    def __setattr__(self, key, value):
+        if getattr(self, "_initialized", False) and key in [
+            "api_key",
+            "api_version",
+        ]:
+            raise AttributeError(
+                f"Cannot modify '{key}' after initialization. "
+                f"Please set a new service object for new keys."
+            )
+        super().__setattr__(key, value)
+
+    def check_rate_limiter(
+        self,
+        anthropic_model: AnthropicModel,
+        limit_requests: int = None,
+        limit_tokens: int = None,
+    ):
+        # Map model versions to their base models for shared rate limiting
+        shared_models = {
+            "claude-3-opus-20240229": "claude-3-opus",
+            "claude-3-sonnet-20240229": "claude-3-sonnet",
+            "claude-3-haiku-20240307": "claude-3-haiku",
+        }
+
+        if anthropic_model.model in shared_models:
+            model = shared_models[anthropic_model.model]
+        else:
+            model = anthropic_model.model
+
+        if model not in self.rate_limiters:
+            self.rate_limiters[model] = anthropic_model.rate_limiter
+        else:
+            anthropic_model.rate_limiter = self.rate_limiters[model]
+            if limit_requests:
+                anthropic_model.rate_limiter.limit_requests = limit_requests
+            if limit_tokens:
+                anthropic_model.rate_limiter.limit_tokens = limit_tokens
+
+        return anthropic_model
+
+    @staticmethod
+    def match_data_model(task_name: str) -> dict:
+        """Match task name to appropriate request and response models."""
+        if task_name == "create_message":
+            return {"request_body": AnthropicMessageRequestBody}
+        raise ValueError(f"No data models found for task: {task_name}")
+
+    @classmethod
+    def list_tasks(cls):
+        methods = []
+        for name, member in inspect.getmembers(
+            cls, predicate=inspect.isfunction
+        ):
+            if name not in [
+                "__init__",
+                "__setattr__",
+                "check_rate_limiter",
+                "match_data_model",
+            ]:
+                methods.append(name)
+        return methods
+
+    # Messages
+    def create_message(
+        self, model: str, limit_tokens: int = None, limit_requests: int = None
+    ):
+        model_obj = AnthropicModel(
+            model=model,
+            api_key=self.api_key,
+            api_version=self.api_version,
+            endpoint="messages",
+            method="POST",
+            content_type="application/json",
+            limit_tokens=limit_tokens,
+            limit_requests=limit_requests,
+        )
+
+        return self.check_rate_limiter(
+            model_obj, limit_requests=limit_requests, limit_tokens=limit_tokens
+        )

lionagi/integrations/anthropic_/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0

lionagi/integrations/anthropic_/anthropic_max_output_token_data.yaml

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+claude-3-opus-20240229: 4096
+claude-3-sonnet-20240229: 4096
+claude-3-haiku-20240307: 4096