perplexityai 0.7.2__py3-none-any.whl → 0.9.0__py3-none-any.whl

perplexity/types/async_/chat/completion_create_params.py

@@ -2,93 +2,238 @@
 
 from __future__ import annotations
 
-from typing import Iterable, Optional
-from typing_extensions import Literal, Required, TypedDict
+from typing import Dict, Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
 from ...._types import SequenceNotStr
-from ...shared_params.chat_message import ChatMessage
-
-__all__ = ["CompletionCreateParams", "Request", "RequestWebSearchOptions", "RequestWebSearchOptionsUserLocation"]
+from ...shared_params.chat_message_input import ChatMessageInput
+
+__all__ = [
+    "CompletionCreateParams",
+    "Request",
+    "RequestDebugParams",
+    "RequestResponseFormat",
+    "RequestResponseFormatResponseFormatText",
+    "RequestResponseFormatResponseFormatJsonSchema",
+    "RequestResponseFormatResponseFormatJsonSchemaJsonSchema",
+    "RequestResponseFormatResponseFormatRegex",
+    "RequestResponseFormatResponseFormatRegexRegex",
+    "RequestTool",
+    "RequestToolFunction",
+    "RequestToolFunctionParameters",
+    "RequestWebSearchOptions",
+    "RequestWebSearchOptionsUserLocation",
+]
 
 
 class CompletionCreateParams(TypedDict, total=False):
     request: Required[Request]
 
+    idempotency_key: Optional[str]
+
+
+class RequestDebugParams(TypedDict, total=False):
+    summarizer_model_override: Optional[str]
+
+    summarizer_prompt_override: Optional[str]
+
+
+class RequestResponseFormatResponseFormatText(TypedDict, total=False):
+    type: Required[Literal["text"]]
+
+
+class RequestResponseFormatResponseFormatJsonSchemaJsonSchema(TypedDict, total=False):
+    schema: Required[Dict[str, object]]
+
+    description: Optional[str]
+
+    name: Optional[str]
+
+    strict: Optional[bool]
+
+
+class RequestResponseFormatResponseFormatJsonSchema(TypedDict, total=False):
+    json_schema: Required[RequestResponseFormatResponseFormatJsonSchemaJsonSchema]
+
+    type: Required[Literal["json_schema"]]
+
+
+class RequestResponseFormatResponseFormatRegexRegex(TypedDict, total=False):
+    regex: Required[str]
+
+    description: Optional[str]
+
+    name: Optional[str]
+
+    strict: Optional[bool]
+
+
+class RequestResponseFormatResponseFormatRegex(TypedDict, total=False):
+    regex: Required[RequestResponseFormatResponseFormatRegexRegex]
+
+    type: Required[Literal["regex"]]
+
+
+RequestResponseFormat: TypeAlias = Union[
+    RequestResponseFormatResponseFormatText,
+    RequestResponseFormatResponseFormatJsonSchema,
+    RequestResponseFormatResponseFormatRegex,
+]
+
+
+class RequestToolFunctionParameters(TypedDict, total=False):
+    properties: Required[Dict[str, object]]
+
+    type: Required[str]
+
+    additional_properties: Optional[bool]
+
+    required: Optional[SequenceNotStr[str]]
+
+
+class RequestToolFunction(TypedDict, total=False):
+    description: Required[str]
+
+    name: Required[str]
+
+    parameters: Required[RequestToolFunctionParameters]
+
+    strict: Optional[bool]
+
+
+class RequestTool(TypedDict, total=False):
+    function: Required[RequestToolFunction]
+
+    type: Required[Literal["function"]]
+
 
 class RequestWebSearchOptionsUserLocation(TypedDict, total=False):
     city: Optional[str]
 
     country: Optional[str]
-    """Two-letter ISO country code"""
 
     latitude: Optional[float]
 
     longitude: Optional[float]
 
     region: Optional[str]
-    """State/province name"""
 
 
 class RequestWebSearchOptions(TypedDict, total=False):
-    image_search_relevance_enhanced: bool
-    """Improves relevance of image search results"""
+    image_results_enhanced_relevance: bool
 
     search_context_size: Literal["low", "medium", "high"]
-    """
-    Amount of search context retrieved: low (cost-saving), medium (balanced), high
-    (comprehensive)
-    """
 
-    user_location: RequestWebSearchOptionsUserLocation
+    search_type: Literal["fast", "pro", "auto"]
+
+    user_location: Optional[RequestWebSearchOptionsUserLocation]
 
 
 class Request(TypedDict, total=False):
-    messages: Required[Iterable[ChatMessage]]
-    """A list of messages comprising the conversation so far"""
+    messages: Required[Iterable[ChatMessageInput]]
+
+    model: Required[str]
 
-    model: Required[Literal["sonar", "sonar-pro", "sonar-deep-research", "sonar-reasoning", "sonar-reasoning-pro"]]
-    """The name of the model that will complete your prompt"""
+    _debug_pro_search: bool
 
-    disable_search: bool
-    """Disables web search completely - model uses only training data"""
+    _inputs: Optional[Iterable[int]]
 
-    enable_search_classifier: bool
-    """Enables classifier that decides if web search is needed"""
+    _is_browser_agent: Optional[bool]
+
+    _prompt_token_length: Optional[int]
+
+    best_of: Optional[int]
+
+    country: Optional[str]
+
+    cum_logprobs: Optional[bool]
+
+    debug_params: Optional[RequestDebugParams]
+
+    disable_search: Optional[bool]
+
+    diverse_first_token: Optional[bool]
+
+    enable_search_classifier: Optional[bool]
+
+    file_workspace_id: Optional[str]
+
+    frequency_penalty: Optional[float]
+
+    has_image_url: bool
+
+    image_domain_filter: Optional[SequenceNotStr[str]]
+
+    image_format_filter: Optional[SequenceNotStr[str]]
 
     last_updated_after_filter: Optional[str]
-    """Only include content last updated after this date (YYYY-MM-DD)"""
 
     last_updated_before_filter: Optional[str]
-    """Only include content last updated before this date (YYYY-MM-DD)"""
 
-    reasoning_effort: Optional[Literal["low", "medium", "high"]]
-    """Controls computational effort for sonar-deep-research model.
+    latitude: Optional[float]
+
+    logprobs: Optional[bool]
+
+    longitude: Optional[float]
+
+    max_tokens: Optional[int]
+
+    n: Optional[int]
 
-    Higher effort = more thorough but more tokens
-    """
+    num_images: int
 
-    return_images: bool
-    """Whether to include images in search results"""
+    num_search_results: int
 
-    return_related_questions: bool
-    """Whether to return related questions"""
+    parallel_tool_calls: Optional[bool]
+
+    presence_penalty: Optional[float]
+
+    ranking_model: Optional[str]
+
+    reasoning_effort: Optional[Literal["minimal", "low", "medium", "high"]]
+
+    response_format: Optional[RequestResponseFormat]
+
+    response_metadata: Optional[Dict[str, object]]
+
+    return_images: Optional[bool]
+
+    return_related_questions: Optional[bool]
+
+    safe_search: Optional[bool]
 
     search_after_date_filter: Optional[str]
-    """Only include content published after this date (YYYY-MM-DD)"""
 
     search_before_date_filter: Optional[str]
-    """Only include content published before this date (YYYY-MM-DD)"""
 
     search_domain_filter: Optional[SequenceNotStr[str]]
-    """List of domains to limit search results to. Use '-' prefix to exclude domains"""
+
+    search_internal_properties: Optional[Dict[str, object]]
 
     search_mode: Optional[Literal["web", "academic", "sec"]]
-    """
-    Type of search: 'web' for general, 'academic' for scholarly, 'sec' for SEC
-    filings
-    """
 
     search_recency_filter: Optional[Literal["hour", "day", "week", "month", "year"]]
-    """Filter results by how recently they were published"""
+
+    search_tenant: Optional[str]
+
+    stop: Union[str, SequenceNotStr[str], None]
+
+    stream: Optional[bool]
+
+    temperature: Optional[float]
+
+    tool_choice: Optional[Literal["none", "auto", "required"]]
+
+    tools: Optional[Iterable[RequestTool]]
+
+    top_k: Optional[int]
+
+    top_logprobs: Optional[int]
+
+    top_p: Optional[float]
+
+    updated_after_timestamp: Optional[int]
+
+    updated_before_timestamp: Optional[int]
 
     web_search_options: RequestWebSearchOptions

perplexity/types/async_/chat/completion_create_response.py

@@ -4,43 +4,44 @@ from typing import List, Optional
 from typing_extensions import Literal
 
 from ...._models import BaseModel
+from ...shared.choice import Choice
 from ...shared.usage_info import UsageInfo
-from ...shared.chat_choice import ChatChoice
-from ...shared.search_result import SearchResult
+from ...shared.api_public_search_result import APIPublicSearchResult
 
 __all__ = ["CompletionCreateResponse", "Response"]
 
 
 class Response(BaseModel):
     id: str
-    """Unique identifier for the chat completion"""
 
-    choices: List[ChatChoice]
+    choices: List[Choice]
 
     created: int
-    """Unix timestamp of creation"""
 
     model: str
-    """The model used"""
-
-    object: str
 
     usage: UsageInfo
 
-    search_results: Optional[List[SearchResult]] = None
-    """Search results used in generating the response"""
+    citations: Optional[List[str]] = None
+
+    object: Optional[str] = None
+
+    search_results: Optional[List[APIPublicSearchResult]] = None
+
+    status: Optional[Literal["PENDING", "COMPLETED"]] = None
+
+    type: Optional[Literal["message", "info", "end_of_stream"]] = None
 
 
 class CompletionCreateResponse(BaseModel):
     id: str
-    """Unique identifier for the async job"""
 
     created_at: int
-    """Unix timestamp of creation"""
 
     model: str
 
     status: Literal["CREATED", "IN_PROGRESS", "COMPLETED", "FAILED"]
+    """Status enum for async processing."""
 
     completed_at: Optional[int] = None
 
@@ -49,6 +50,5 @@ class CompletionCreateResponse(BaseModel):
     failed_at: Optional[int] = None
 
     response: Optional[Response] = None
-    """The completion response when status is COMPLETED"""
 
     started_at: Optional[int] = None

perplexity/types/async_/chat/completion_get_params.py

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+
+__all__ = ["CompletionGetParams"]
+
+
+class CompletionGetParams(TypedDict, total=False):
+    local_mode: bool
+
+    x_client_env: Annotated[str, PropertyInfo(alias="x-client-env")]
+
+    x_client_name: Annotated[str, PropertyInfo(alias="x-client-name")]
+
+    x_request_time: Annotated[str, PropertyInfo(alias="x-request-time")]
+
+    x_usage_tier: Annotated[str, PropertyInfo(alias="x-usage-tier")]
+
+    x_user_id: Annotated[str, PropertyInfo(alias="x-user-id")]

perplexity/types/async_/chat/completion_get_response.py

@@ -4,43 +4,44 @@ from typing import List, Optional
 from typing_extensions import Literal
 
 from ...._models import BaseModel
+from ...shared.choice import Choice
 from ...shared.usage_info import UsageInfo
-from ...shared.chat_choice import ChatChoice
-from ...shared.search_result import SearchResult
+from ...shared.api_public_search_result import APIPublicSearchResult
 
 __all__ = ["CompletionGetResponse", "Response"]
 
 
 class Response(BaseModel):
     id: str
-    """Unique identifier for the chat completion"""
 
-    choices: List[ChatChoice]
+    choices: List[Choice]
 
     created: int
-    """Unix timestamp of creation"""
 
     model: str
-    """The model used"""
-
-    object: str
 
     usage: UsageInfo
 
-    search_results: Optional[List[SearchResult]] = None
-    """Search results used in generating the response"""
+    citations: Optional[List[str]] = None
+
+    object: Optional[str] = None
+
+    search_results: Optional[List[APIPublicSearchResult]] = None
+
+    status: Optional[Literal["PENDING", "COMPLETED"]] = None
+
+    type: Optional[Literal["message", "info", "end_of_stream"]] = None
 
 
 class CompletionGetResponse(BaseModel):
     id: str
-    """Unique identifier for the async job"""
 
     created_at: int
-    """Unix timestamp of creation"""
 
     model: str
 
     status: Literal["CREATED", "IN_PROGRESS", "COMPLETED", "FAILED"]
+    """Status enum for async processing."""
 
     completed_at: Optional[int] = None
 
@@ -49,6 +50,5 @@ class CompletionGetResponse(BaseModel):
     failed_at: Optional[int] = None
 
     response: Optional[Response] = None
-    """The completion response when status is COMPLETED"""
 
     started_at: Optional[int] = None

perplexity/types/async_/chat/completion_list_response.py

@@ -16,6 +16,7 @@ class Request(BaseModel):
     model: str
 
     status: Literal["CREATED", "IN_PROGRESS", "COMPLETED", "FAILED"]
+    """Status enum for async processing."""
 
     completed_at: Optional[int] = None
 
@@ -28,4 +29,3 @@ class CompletionListResponse(BaseModel):
     requests: List[Request]
 
     next_token: Optional[str] = None
-    """Token for pagination"""