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

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

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

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

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

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

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

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

lionagi/integrations/pydantic_/__init__.py

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

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

@@ -0,0 +1,208 @@
+# 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/integrations/services.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .anthropic_.AnthropicService import AnthropicService
+from .groq_.GroqService import GroqService
+from .ollama_.OllamaService import OllamaService
+from .openai_.OpenAIService import OpenAIService
+from .perplexity_.PerplexityService import PerplexityService
+
+__all__ = (
+    "AnthropicService",
+    "GroqService",
+    "OllamaService",
+    "OpenAIService",
+    "PerplexityService",
+)

lionagi/libs/__init__.py

@@ -1,55 +0,0 @@
-import lionagi.libs.ln_convert as convert
-import lionagi.libs.ln_dataframe as dataframe
-import lionagi.libs.ln_func_call as func_call
-import lionagi.libs.ln_nested as nested
-from lionagi.libs.ln_api import (
-    APIUtil,
-    BaseService,
-    PayloadPackage,
-    SimpleRateLimiter,
-    StatusTracker,
-)
-from lionagi.libs.ln_async import AsyncUtil
-from lionagi.libs.ln_convert import (
-    to_df,
-    to_dict,
-    to_list,
-    to_num,
-    to_readable_dict,
-    to_str,
-)
-from lionagi.libs.ln_func_call import CallDecorator, lcall
-from lionagi.libs.ln_image import ImageUtil
-from lionagi.libs.ln_nested import nget, ninsert, nset
-from lionagi.libs.ln_parse import ParseUtil, StringMatch
-from lionagi.libs.ln_validate import validation_funcs
-from lionagi.libs.sys_util import SysUtil
-
-__all__ = [
-    "SysUtil",
-    "convert",
-    "func_call",
-    "dataframe",
-    "nested",
-    "AsyncUtil",
-    "ParseUtil",
-    "StringMatch",
-    "APIUtil",
-    "BaseService",
-    "PayloadPackage",
-    "StatusTracker",
-    "SimpleRateLimiter",
-    "CallDecorator",
-    "validation_funcs",
-    "ImageUtil",
-    "to_str",
-    "to_list",
-    "to_dict",
-    "to_df",
-    "lcall",
-    "to_readable_dict",
-    "to_num",
-    "nget",
-    "nset",
-    "ninsert",
-]

lionagi/libs/compress/models.py

@@ -0,0 +1,62 @@
+import numpy as np
+from pydantic import BaseModel
+
+from lionagi.core.generic import Log
+from lionagi.core.typing import Note
+
+
+class PerplexityTokenScore(BaseModel):
+    token: str
+    logprob: float
+
+
+class PerplexityScores(BaseModel):
+
+    completion_response: BaseModel
+    original_tokens: list[str]
+    n_samples: int
+
+    @property
+    def logprobs(self) -> list[float]:
+        return [i.logprob for i in self.perplexity_scores]
+
+    @property
+    def predicted_tokens(self) -> list[str]:
+        return [i.token for i in self.perplexity_scores]
+
+    @property
+    def perplexity(self) -> float:
+        return np.exp(np.mean(self.logprobs))
+
+    @property
+    def perplexity_scores(self) -> list[PerplexityTokenScore]:
+        outs = []
+        log_prob = self.completion_response.choices[0].logprobs
+        n = Note.from_dict(log_prob)
+        for j in range(len(n[["content"]])):
+            p_ = ["content", j]
+            p_token = p_ + ["token"]
+            p_logprob = p_ + ["logprob"]
+            p_score = PerplexityTokenScore(
+                token=n[p_token], logprob=n[p_logprob]
+            )
+            outs.append(p_score)
+        return outs
+
+    @property
+    def prompt_tokens(self) -> int:
+        return self.completion_response.usage.prompt_tokens
+
+    @property
+    def completion_tokens(self) -> int:
+        return self.completion_response.usage.completion_tokens
+
+    def to_log(self) -> Log:
+        dict_ = self.model_dump()
+        info = dict_.pop("completion_response")
+        dict_["perplexity"] = self.perplexity
+        dict_["prompt_tokens"] = self.prompt_tokens
+        dict_["completion_tokens"] = self.completion_tokens
+        dict_["perplexity_scores"] = self.perplexity_scores
+
+        return Log(content=dict_, info=info)