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

lionagi/integrations/perplexity_/api_endpoints/chat_completions/response/response_body.py

@@ -1,146 +0,0 @@
-from typing import List, Optional, Union
-
-from pydantic import BaseModel, ConfigDict, Field, field_validator
-
-from lionagi.integrations.perplexity_.api_endpoints.data_models import (
-    Citation,
-    PerplexityEndpointResponseBody,
-    Usage,
-)
-
-
-class Message(BaseModel):
-    """A message in the chat completion response."""
-
-    role: str = Field(description="The role of the message author.")
-    content: str = Field(description="The content of the message.")
-
-    model_config = ConfigDict(extra="forbid")
-
-    @field_validator("role")
-    @classmethod
-    def validate_role(cls, role: str) -> str:
-        valid_roles = [
-            "assistant"
-        ]  # Response messages are always from assistant
-        if role not in valid_roles:
-            raise ValueError(f"Role must be one of {valid_roles}")
-        return role
-
-    @field_validator("content")
-    @classmethod
-    def validate_content(cls, content: str) -> str:
-        if not content or not content.strip():
-            raise ValueError("Content cannot be empty")
-        return content
-
-
-class Choice(BaseModel):
-    """A completion choice returned by the model."""
-
-    index: int = Field(
-        description="The index of this choice in the list of choices."
-    )
-    message: Message = Field(description="The message generated by the model.")
-    finish_reason: str | None = Field(
-        description="The reason the model stopped generating tokens. Either 'stop' or 'length'."
-    )
-
-    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
-
-    @field_validator("finish_reason")
-    @classmethod
-    def validate_finish_reason(cls, finish_reason: str | None) -> str | None:
-        if finish_reason is not None:
-            valid_reasons = ["stop", "length"]
-            if finish_reason not in valid_reasons:
-                raise ValueError(
-                    f"Finish reason must be one of {valid_reasons}"
-                )
-        return finish_reason
-
-
-class RelatedQuestion(BaseModel):
-    """A related question suggested by the model."""
-
-    text: str = Field(description="The text of the related question.")
-
-    model_config = ConfigDict(extra="forbid")
-
-    @field_validator("text")
-    @classmethod
-    def validate_text(cls, text: str) -> str:
-        if not text or not text.strip():
-            raise ValueError("Text cannot be empty")
-        return text
-
-
-class PerplexityChatCompletionResponseBody(PerplexityEndpointResponseBody):
-    """Response body for chat completion requests."""
-
-    id: str = Field(description="A unique identifier for this completion.")
-    model: str = Field(description="The model used for completion.")
-    object: str = Field(
-        description="The object type, always 'chat.completion'."
-    )
-    created: int = Field(
-        description="Unix timestamp of when the completion was created."
-    )
-    choices: list[Choice] = Field(
-        description="The list of completion choices."
-    )
-    usage: Usage = Field(
-        description="Token usage information for this request."
-    )
-    citations: list[Citation | dict | str] | None = Field(
-        default=None,
-        description="Citations for the generated answer. Can be Citation objects, dictionaries, or URL strings.",
-    )
-    related_questions: list[RelatedQuestion] | None = Field(
-        default=None, description="Related questions suggested by the model."
-    )
-
-    model_config = ConfigDict(extra="forbid")
-
-    @field_validator("object")
-    @classmethod
-    def validate_object(cls, object_type: str) -> str:
-        if object_type != "chat.completion":
-            raise ValueError("Object type must be 'chat.completion'")
-        return object_type
-
-    @field_validator("choices")
-    @classmethod
-    def validate_choices(cls, choices: list[Choice]) -> list[Choice]:
-        if not choices:
-            raise ValueError("At least one choice is required")
-        return choices
-
-    @field_validator("citations")
-    @classmethod
-    def validate_citations(
-        cls, citations: list[Citation | dict | str] | None
-    ) -> list[Citation | dict | str] | None:
-        if citations is not None:
-            if len(citations) > 10:  # Arbitrary limit for safety
-                raise ValueError("Too many citations")
-            # Convert string citations to Citation objects
-            processed_citations = []
-            for citation in citations:
-                if isinstance(citation, str):
-                    processed_citations.append({"url": citation})
-                else:
-                    processed_citations.append(citation)
-            return processed_citations
-        return citations
-
-    @field_validator("related_questions")
-    @classmethod
-    def validate_related_questions(
-        cls, questions: list[RelatedQuestion] | None
-    ) -> list[RelatedQuestion] | None:
-        if (
-            questions is not None and len(questions) > 10
-        ):  # Arbitrary limit for safety
-            raise ValueError("Too many related questions")
-        return questions

lionagi/integrations/perplexity_/api_endpoints/data_models.py

@@ -1,63 +0,0 @@
-from typing import List, Optional
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class PerplexityEndpointRequestBody(BaseModel):
-    """Base class for all Perplexity API endpoint request bodies."""
-
-    model_config = ConfigDict(
-        extra="forbid",
-        use_enum_values=True,
-        validate_assignment=True,
-        arbitrary_types_allowed=True,
-    )
-
-
-class PerplexityEndpointResponseBody(BaseModel):
-    """Base class for all Perplexity API endpoint response bodies."""
-
-    model_config = ConfigDict(
-        use_enum_values=True,
-        validate_assignment=True,
-        arbitrary_types_allowed=True,
-    )
-
-
-class Usage(BaseModel):
-    """Token usage information for a request."""
-
-    prompt_tokens: int = Field(
-        description="Number of tokens in the prompt.",
-        ge=0,
-    )
-    completion_tokens: int = Field(
-        description="Number of tokens in the completion.",
-        ge=0,
-    )
-    total_tokens: int = Field(
-        description="Total number of tokens used in the request.",
-        ge=0,
-    )
-
-    model_config = ConfigDict(extra="forbid")
-
-
-class Citation(BaseModel):
-    """Citation information for a response."""
-
-    url: str = Field(description="The URL of the cited source.")
-    text: str | None = Field(
-        default=None, description="The relevant text from the source."
-    )
-    title: str | None = Field(
-        default=None, description="The title of the source."
-    )
-    year: int | None = Field(
-        default=None, description="The year of publication.", ge=0
-    )
-    author: str | None = Field(
-        default=None, description="The author of the source."
-    )
-
-    model_config = ConfigDict(extra="forbid")

lionagi/integrations/perplexity_/api_endpoints/match_response.py

@@ -1,26 +0,0 @@
-from typing import Any, Dict, List, Union
-
-from lionagi.integrations.perplexity_.api_endpoints.api_request import (
-    PerplexityRequest,
-)
-from lionagi.integrations.perplexity_.api_endpoints.chat_completions.response.response_body import (
-    PerplexityChatCompletionResponseBody,
-)
-
-
-def match_response(
-    request_model: PerplexityRequest,
-    response_body: dict[str, Any] | list[dict[str, Any]],
-) -> PerplexityChatCompletionResponseBody | list[dict[str, Any]]:
-    """Match the response body to the appropriate response model based on the endpoint."""
-
-    if not response_body:
-        return response_body
-
-    if isinstance(response_body, list):
-        return response_body
-
-    if request_model.endpoint == "chat/completions":
-        return PerplexityChatCompletionResponseBody(**response_body)
-
-    return response_body

lionagi/integrations/perplexity_/perplexity_max_output_token_data.yaml

@@ -1,3 +0,0 @@
-llama-3.1-sonar-small-128k-online: 4096
-llama-3.1-sonar-medium-128k-online: 4096
-llama-3.1-sonar-large-128k-online: 4096

lionagi/integrations/perplexity_/perplexity_price_data.yaml

@@ -1,10 +0,0 @@
-model:
-  llama-3.1-sonar-small-128k-online:
-    input_tokens: 0.000001
-    output_tokens: 0.000002
-  llama-3.1-sonar-medium-128k-online:
-    input_tokens: 0.000002
-    output_tokens: 0.000004
-  llama-3.1-sonar-large-128k-online:
-    input_tokens: 0.000004
-    output_tokens: 0.000008

lionagi/integrations/perplexity_/version.py

@@ -1 +0,0 @@
-__version__ = "1.0.0"

lionagi/integrations/pydantic_/__init__.py

@@ -1,8 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from .break_down_annotation import break_down_pydantic_annotation
-from .new_model import new_model
-
-__all__ = ["break_down_pydantic_annotation", "new_model"]

lionagi/integrations/pydantic_/break_down_annotation.py

@@ -1,81 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from inspect import isclass
-from typing import Any, TypeVar, get_args, get_origin
-
-from pydantic import BaseModel
-
-T = TypeVar("T", bound=BaseModel)
-
-
-def break_down_pydantic_annotation(
-    model: type[T], max_depth: int | None = None, current_depth: int = 0
-) -> dict[str, Any]:
-    """
-    Break down the type annotations of a Pydantic model into a dictionary.
-
-    This function recursively processes Pydantic models, converting their
-    field annotations into a dictionary structure. It handles nested models
-    and lists of models.
-
-    Args:
-        model: The Pydantic model class to break down.
-        max_depth: Maximum depth for recursion. None for no limit.
-        current_depth: Current recursion depth (used internally).
-
-    Returns:
-        A dictionary representing the structure of the model's annotations.
-
-    Raises:
-        TypeError: If the input is not a Pydantic model.
-        RecursionError: If max recursion depth is reached.
-
-    Example:
-        >>> from pydantic import BaseModel
-        >>> class SubModel(BaseModel):
-        ...     field1: int
-        ...     field2: str
-        >>> class MainModel(BaseModel):
-        ...     sub: SubModel
-        ...     items: list[SubModel]
-        >>> result = break_down_annotation(MainModel)
-        >>> print(result)
-        {
-            'sub': {'field1': <class 'int'>, 'field2': <class 'str'>},
-            'items': [{'field1': <class 'int'>, 'field2': <class 'str'>}]
-        }
-    """
-
-    if not _is_pydantic_model(model):
-        raise TypeError("Input must be a Pydantic model")
-
-    if max_depth is not None and current_depth >= max_depth:
-        raise RecursionError("Maximum recursion depth reached")
-
-    out: dict[str, Any] = {}
-    for k, v in model.__annotations__.items():
-        origin = get_origin(v)
-        if _is_pydantic_model(v):
-            out[k] = break_down_pydantic_annotation(
-                v, max_depth, current_depth + 1
-            )
-        elif origin is list:
-            args = get_args(v)
-            if args and _is_pydantic_model(args[0]):
-                out[k] = [
-                    break_down_pydantic_annotation(
-                        args[0], max_depth, current_depth + 1
-                    )
-                ]
-            else:
-                out[k] = [args[0] if args else Any]
-        else:
-            out[k] = v
-
-    return out
-
-
-def _is_pydantic_model(x: Any) -> bool:
-    return isclass(x) and issubclass(x, BaseModel)

lionagi/integrations/pydantic_/new_model.py

@@ -1,208 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-
-from collections.abc import Callable
-from typing import Any, Literal, TypeVar, overload
-
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    Field,
-    create_model,
-    field_validator,
-)
-from pydantic.fields import FieldInfo
-
-T = TypeVar("T", bound=BaseModel)
-
-
-@overload
-def new_model(
-    base: type[T],
-    *,
-    model_name: str | None = None,
-    use_all_fields: Literal[False] = False,
-    config_dict: ConfigDict | None = None,
-    doc: str | None = None,
-    validators: dict[str, Callable] | None = None,
-    use_base_kwargs: bool = False,
-    inherit_base: bool = False,
-    extra_fields: dict[str, Any] | None = None,
-    field_descriptions: dict[str, str] | None = None,
-    exclude_fields: list[str] | None = None,
-    frozen: bool = False,
-) -> type[BaseModel]: ...
-
-
-@overload
-def new_model(
-    base: type[T],
-    *,
-    model_name: str | None = None,
-    use_all_fields: Literal[True],
-    config_dict: ConfigDict | None = None,
-    doc: str | None = None,
-    validators: dict[str, Callable] | None = None,
-    use_base_kwargs: bool = False,
-    inherit_base: bool = False,
-    extra_fields: dict[str, Any] | None = None,
-    field_descriptions: dict[str, str] | None = None,
-    exclude_fields: list[str] | None = None,
-    frozen: bool = False,
-) -> type[BaseModel]: ...
-
-
-def new_model(
-    base: type[T] | T,
-    *,
-    model_name: str | None = None,
-    use_all_fields: bool = False,
-    config_dict: ConfigDict | None = None,
-    doc: str | None = None,
-    validators: dict[str, Callable] | None = None,
-    use_base_kwargs: bool = False,
-    inherit_base: bool = False,
-    extra_fields: dict[str, Any] | None = None,
-    field_descriptions: dict[str, str] | None = None,
-    exclude_fields: list[str] | None = None,
-    frozen: bool = False,
-) -> type[BaseModel]:
-    """
-    Create a new Pydantic model based on an existing model with additional customizations.
-
-    This function allows you to create a new Pydantic model by extending or modifying
-    an existing model. It provides various options to customize the new model's fields,
-    configuration, and behavior.
-
-    Args:
-        base: The base model or instance to derive the new model from.
-        model_name: Name for the new model. Defaults to f"Dynamic{base.__name__}".
-        use_all_fields: If True, includes fields from base.all_fields (if available).
-        config_dict: Additional configuration options for the model.
-        doc: Docstring for the new model.
-        validators: Dictionary of field validators to add to the model.
-        use_base_kwargs: If True, includes class kwargs from the base model.
-        inherit_base: If True, sets the base model as the parent class.
-        extra_fields: Additional fields to add to the new model.
-        field_descriptions: Dictionary of field descriptions to add or update.
-        exclude_fields: List of field names to exclude from the new model.
-        frozen: If True, creates an immutable model.
-
-    Returns:
-        A new Pydantic model class.
-
-    Raises:
-        ValueError: If invalid arguments are provided.
-
-    Examples:
-        >>> class BaseUser(BaseModel):
-        ...     name: str
-        ...     age: int
-        >>> NewUser = new_model(
-        ...     BaseUser,
-        ...     model_name="ExtendedUser",
-        ...     extra_fields={"email": (str, ...)},
-        ...     field_descriptions={"name": "Full name of the user"},
-        ...     frozen=True
-        ... )
-        >>> print(NewUser.model_fields.keys())
-        dict_keys(['name', 'age', 'email'])
-
-        >>> class AdvancedUser(BaseModel):
-        ...     details: dict[str, Any]
-        ...
-        ...     class Config:
-        ...         extra = 'allow'
-        >>> EnhancedUser = new_model(
-        ...     AdvancedUser,
-        ...     use_all_fields=True,
-        ...     inherit_base=True,
-        ...     config_dict={'json_schema_extra': {'examples': [{'details': {'key': 'value'}}]}}
-        ... )
-        >>> print(EnhancedUser.model_config)
-        {'extra': 'allow', 'json_schema_extra': {'examples': [{'details': {'key': 'value'}}]}}
-    """
-    if not isinstance(base, type) or not issubclass(base, BaseModel):
-        if not isinstance(base, BaseModel):
-            raise ValueError("base must be a Pydantic model class or instance")
-        base = type(base)
-
-    # Prepare fields
-    fields = {}
-    if use_all_fields and hasattr(base, "all_fields"):
-        fields.update(base.all_fields)
-    else:
-        fields.update(base.model_fields)
-
-    # Exclude fields
-    if exclude_fields:
-        for field in exclude_fields:
-            fields.pop(field, None)
-
-    # Add extra fields
-    if extra_fields:
-        fields.update(extra_fields)
-
-    # Update field descriptions
-    if field_descriptions:
-        for field_name, description in field_descriptions.items():
-            if field_name in fields:
-                field_info = fields[field_name]
-                if isinstance(field_info, tuple):
-                    fields[field_name] = (
-                        field_info[0],
-                        Field(..., description=description),
-                    )
-                elif isinstance(field_info, FieldInfo):
-                    fields[field_name] = field_info.model_copy(
-                        update={"description": description}
-                    )
-
-    # Prepare config
-    config = ConfigDict()
-    if config_dict:
-        config.update(config_dict)
-    if frozen:
-        config["frozen"] = True
-
-    # Prepare class attributes
-    class_kwargs = {}
-    if use_base_kwargs:
-        class_kwargs.update(
-            {
-                k: getattr(base, k)
-                for k in base.__dict__
-                if not k.startswith("__")
-            }
-        )
-
-    # Create the model
-    new_model_name = model_name or f"Dynamic{base.__name__}"
-    model: type[BaseModel] = create_model(
-        new_model_name, __base__=base if inherit_base else BaseModel, **fields
-    )
-
-    # Set config
-    if config:
-        model.model_config = config
-
-    # Set docstring
-    if doc:
-        model.__doc__ = doc
-
-    # Add validators
-    if validators:
-        for field, validator_func in validators.items():
-            setattr(
-                model,
-                f"validate_{field}",
-                field_validator(field)(validator_func),
-            )
-
-    # Add class attributes
-    for key, value in class_kwargs.items():
-        setattr(model, key, value)
-
-    return model

lionagi/libs/constants.py

@@ -1,98 +0,0 @@
-from typing import Any, Final, Literal, TypedDict, TypeVar, Union
-
-
-class UndefinedType:
-    def __init__(self) -> None:
-        self.undefined = True
-
-    def __bool__(self) -> Literal[False]:
-        return False
-
-    def __deepcopy__(self, memo):
-        # Ensure UNDEFINED is universal
-        return self
-
-    def __repr__(self) -> Literal["UNDEFINED"]:
-        return "UNDEFINED"
-
-    __slots__ = ["undefined"]
-
-
-UNDEFINED = UndefinedType()
-
-# Type definitions
-NUM_TYPE_LITERAL = Literal["int", "float", "complex"]
-NUM_TYPES = Union[type[int], type[float], type[complex], NUM_TYPE_LITERAL]
-NumericType = TypeVar("NumericType", int, float, complex)
-
-# Type mapping
-TYPE_MAP = {"int": int, "float": float, "complex": complex}
-
-# Regex patterns for different numeric formats
-PATTERNS = {
-    "scientific": r"[-+]?(?:\d*\.)?\d+[eE][-+]?\d+",
-    "complex_sci": r"[-+]?(?:\d*\.)?\d+(?:[eE][-+]?\d+)?[-+](?:\d*\.)?\d+(?:[eE][-+]?\d+)?[jJ]",
-    "complex": r"[-+]?(?:\d*\.)?\d+[-+](?:\d*\.)?\d+[jJ]",
-    "pure_imaginary": r"[-+]?(?:\d*\.)?\d*[jJ]",
-    "percentage": r"[-+]?(?:\d*\.)?\d+%",
-    "fraction": r"[-+]?\d+/\d+",
-    "decimal": r"[-+]?(?:\d*\.)?\d+",
-    "special": r"[-+]?(?:inf|infinity|nan)",
-}
-
-
-md_json_char_map = {"'": '\\"', "\n": "\\n", "\r": "\\r", "\t": "\\t"}
-
-py_json_msp = {
-    "str": "string",
-    "int": "number",
-    "float": "number",
-    "list": "array",
-    "tuple": "array",
-    "bool": "boolean",
-    "dict": "object",
-}
-
-
-# Define constants for valid boolean string representations
-TRUE_VALUES: Final[frozenset[str]] = frozenset(
-    [
-        "true",
-        "1",
-        "yes",
-        "y",
-        "on",
-        "correct",
-        "t",
-        "enabled",
-        "enable",
-        "active",
-        "activated",
-    ]
-)
-
-FALSE_VALUES: Final[frozenset[str]] = frozenset(
-    [
-        "false",
-        "0",
-        "no",
-        "n",
-        "off",
-        "incorrect",
-        "f",
-        "disabled",
-        "disable",
-        "inactive",
-        "deactivated",
-        "none",
-        "null",
-        "n/a",
-        "na",
-    ]
-)
-
-
-class KeysDict(TypedDict, total=False):
-    """TypedDict for keys dictionary."""
-
-    key: Any  # Represents any key-type pair