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

lionagi/integrations/perplexity_/PerplexityService.py

@@ -1,118 +0,0 @@
-# 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.perplexity_.api_endpoints.chat_completions.request.request_body import (
-    PerplexityChatCompletionRequestBody,
-)
-from lionagi.service import Service, register_service
-
-from .PerplexityModel import PerplexityModel
-
-load_dotenv()
-
-
-@register_service
-class PerplexityService(Service):
-    def __init__(
-        self,
-        api_key: str,
-        name: str = None,
-    ):
-        super().__setattr__("_initialized", False)
-        self.api_key = api_key
-        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",
-        ]:
-            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,
-        perplexity_model: PerplexityModel,
-        limit_requests: int = None,
-        limit_tokens: int = None,
-    ):
-        # Map model versions to their base models for shared rate limiting
-        shared_models = {
-            "llama-3.1-sonar-small-128k-online": "llama-3.1-sonar-small",
-            "llama-3.1-sonar-medium-128k-online": "llama-3.1-sonar-medium",
-            "llama-3.1-sonar-large-128k-online": "llama-3.1-sonar-large",
-        }
-
-        if perplexity_model.model in shared_models:
-            model = shared_models[perplexity_model.model]
-        else:
-            model = perplexity_model.model
-
-        if model not in self.rate_limiters:
-            self.rate_limiters[model] = perplexity_model.rate_limiter
-        else:
-            perplexity_model.rate_limiter = self.rate_limiters[model]
-            if limit_requests:
-                perplexity_model.rate_limiter.limit_requests = limit_requests
-            if limit_tokens:
-                perplexity_model.rate_limiter.limit_tokens = limit_tokens
-
-        return perplexity_model
-
-    @staticmethod
-    def match_data_model(task_name: str) -> dict:
-        """Match task name to appropriate request and response models."""
-        if task_name == "create_chat_completion":
-            return {"request_body": PerplexityChatCompletionRequestBody}
-        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
-
-    # Chat Completions
-    def create_chat_completion(
-        self, model: str, limit_tokens: int = None, limit_requests: int = None
-    ):
-        model_obj = PerplexityModel(
-            model=model,
-            api_key=self.api_key,
-            endpoint="chat/completions",
-            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
-        )
-
-    @property
-    def allowed_roles(self):
-        return ["user", "assistant", "system"]
-
-    @property
-    def sequential_exchange(self):
-        """whether the service requires user/assistant exchange"""
-        return True

lionagi/integrations/perplexity_/api_endpoints/api_request.py

@@ -1,171 +0,0 @@
-import json
-from collections.abc import AsyncGenerator
-from typing import Any, Dict, Optional, Tuple, Union
-
-import aiohttp
-from pydantic import BaseModel, ConfigDict, Field
-
-from lionagi.integrations.perplexity_.api_endpoints.data_models import (
-    PerplexityEndpointRequestBody,
-)
-
-
-class PerplexityRequest(BaseModel):
-    """Handler for making requests to the Perplexity API."""
-
-    api_key: str = Field(
-        description="API key for authentication", exclude=True
-    )
-    endpoint: str = Field(description="Endpoint for request")
-    method: str = Field(description="HTTP method")
-    content_type: str | None = "application/json"
-    base_url: str = "https://api.perplexity.ai"
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-        extra="allow",  # Allow extra attributes for mocking in tests
-    )
-
-    async def invoke(
-        self,
-        json_data: None | (
-            dict[str, Any] | PerplexityEndpointRequestBody
-        ) = None,
-        form_data: BaseModel | None = None,
-        output_file: str | None = None,
-        with_response_header: bool = False,
-        parse_response: bool = True,
-    ) -> dict[str, Any] | tuple[dict[str, Any], dict[str, str]] | bytes | None:
-        """Make a request to the Perplexity API."""
-        url = f"{self.base_url}/{self.endpoint}"
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-        }
-
-        if self.content_type:
-            headers["Content-Type"] = self.content_type
-
-        if isinstance(json_data, PerplexityEndpointRequestBody):
-            json_data = json_data.model_dump(exclude_unset=True)
-
-        async with aiohttp.ClientSession() as client:
-            response = await client.request(
-                method=self.method,
-                url=url,
-                headers=headers,
-                json=json_data,
-                data=form_data.model_dump() if form_data else None,
-            )
-            async with response:
-                if response.status != 200:
-                    try:
-                        error_body = await response.json()
-                        error_msg = error_body.get("error", {}).get(
-                            "message", str(error_body)
-                        )
-                    except Exception:
-                        error_msg = await response.text()
-                    raise Exception(
-                        f"API request failed with status {response.status}: {error_msg}"
-                    )
-
-                if output_file:
-                    with open(output_file, "wb") as f:
-                        async for chunk in response.content.iter_chunked(8192):
-                            f.write(chunk)
-                    return None
-
-                if parse_response:
-                    response_body = await response.json()
-                else:
-                    response_body = await response.text()
-                    try:
-                        response_body = json.loads(response_body)
-                    except json.JSONDecodeError:
-                        pass
-
-                if with_response_header:
-                    headers = {
-                        k.lower(): v for k, v in response.headers.items()
-                    }
-                    return response_body, headers
-                return response_body
-
-    async def stream(
-        self,
-        json_data: None | (
-            dict[str, Any] | PerplexityEndpointRequestBody
-        ) = None,
-        output_file: str | None = None,
-        with_response_header: bool = False,
-        verbose: bool = True,
-    ) -> AsyncGenerator[dict[str, Any], None]:
-        """Stream responses from the Perplexity API."""
-        if isinstance(json_data, PerplexityEndpointRequestBody):
-            json_data = json_data.model_dump(exclude_unset=True)
-
-        if not json_data.get("stream", False):
-            json_data["stream"] = True
-
-        url = f"{self.base_url}/{self.endpoint}"
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "Accept": "text/event-stream",
-        }
-
-        async with aiohttp.ClientSession() as client:
-            response = await client.post(url, headers=headers, json=json_data)
-            async with response:
-                if response.status != 200:
-                    try:
-                        error_body = await response.json()
-                        error_msg = error_body.get("error", {}).get(
-                            "message", str(error_body)
-                        )
-                    except Exception:
-                        error_msg = await response.text()
-                    raise Exception(
-                        f"API request failed with status {response.status}: {error_msg}"
-                    )
-
-                if with_response_header:
-                    headers = {
-                        k.lower(): v for k, v in response.headers.items()
-                    }
-                    yield {"headers": headers}
-
-                file_handle = None
-                if output_file:
-                    try:
-                        file_handle = open(output_file, "w")
-                    except Exception as e:
-                        raise ValueError(
-                            f"Failed to open output file {output_file}: {e}"
-                        )
-
-                try:
-                    async for chunk in response.content:
-                        if chunk:
-                            chunk_str = chunk.decode("utf-8").strip()
-                            if chunk_str.startswith("data: "):
-                                chunk_str = chunk_str[
-                                    6:
-                                ]  # Remove "data: " prefix
-                            try:
-                                chunk_data = json.loads(chunk_str)
-                                if file_handle:
-                                    file_handle.write(
-                                        json.dumps(chunk_data) + "\n"
-                                    )
-                                if verbose and "choices" in chunk_data:
-                                    content = chunk_data["choices"][0][
-                                        "delta"
-                                    ]["content"]
-                                    print(content, end="", flush=True)
-                                yield chunk_data
-                            except json.JSONDecodeError:
-                                continue
-                finally:
-                    if file_handle:
-                        file_handle.close()

lionagi/integrations/perplexity_/api_endpoints/chat_completions/request/request_body.py

@@ -1,121 +0,0 @@
-from pydantic import BaseModel, ConfigDict, Field, field_validator
-
-from lionagi.integrations.perplexity_.api_endpoints.data_models import (
-    PerplexityEndpointRequestBody,
-)
-
-
-class Message(BaseModel):
-    """A message in the chat completion request."""
-
-    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 = ["system", "user", "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 PerplexityChatCompletionRequestBody(PerplexityEndpointRequestBody):
-    """Request body for chat completion requests."""
-
-    model: str = Field(description="ID of the model to use.")
-    messages: list[Message] = Field(
-        description="A list of messages comprising the conversation so far."
-    )
-    max_tokens: int | None = Field(
-        default=None,
-        description="The maximum number of tokens to generate in the completion.",
-        ge=1,
-    )
-    temperature: float | None = Field(
-        default=0.2,
-        description="What sampling temperature to use, between 0 and 2.",
-        ge=0,
-        lt=2,
-    )
-    top_p: float | None = Field(
-        default=0.9,
-        description="An alternative to sampling with temperature, called nucleus sampling.",
-        ge=0,
-        le=1,
-    )
-    search_domain_filter: list[str] | None = Field(
-        default=None,
-        description="List of domains to limit citations to.",
-    )
-    return_images: bool | None = Field(
-        default=False,
-        description="Whether to return images in the response.",
-    )
-    return_related_questions: bool | None = Field(
-        default=False,
-        description="Whether to return related questions in the response.",
-    )
-    search_recency_filter: str | None = Field(
-        default=None,
-        description="Filter for search results recency (month, week, day, hour).",
-    )
-    top_k: int | None = Field(
-        default=0,
-        description="The number of tokens to keep for highest top-k filtering.",
-        ge=0,
-        le=2048,
-    )
-    stream: bool | None = Field(
-        default=False,
-        description="Whether to stream back partial progress.",
-    )
-    presence_penalty: float | None = Field(
-        default=0,
-        description="Penalty for new tokens based on their presence in text so far.",
-        ge=-2,
-        le=2,
-    )
-    frequency_penalty: float | None = Field(
-        default=1,
-        description="Penalty for new tokens based on their frequency in text so far.",
-        gt=0,
-    )
-
-    model_config = ConfigDict(extra="forbid")
-
-    @field_validator("search_recency_filter")
-    @classmethod
-    def validate_search_recency_filter(cls, value: str | None) -> str | None:
-        if value is not None:
-            valid_filters = ["month", "week", "day", "hour"]
-            if value not in valid_filters:
-                raise ValueError(
-                    f"Search recency filter must be one of {valid_filters}"
-                )
-        return value
-
-    @field_validator("search_domain_filter")
-    @classmethod
-    def validate_search_domain_filter(
-        cls, value: list[str] | None
-    ) -> list[str] | None:
-        if value is not None and len(value) > 3:
-            raise ValueError("Search domain filter is limited to 3 domains")
-        return value
-
-    @field_validator("messages")
-    @classmethod
-    def validate_messages(cls, messages: list[Message]) -> list[Message]:
-        if not messages:
-            raise ValueError("At least one message is required")
-        return messages

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.1"

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"]