perplexityai 0.22.3__py3-none-any.whl

perplexity/resources/search.py

@@ -0,0 +1,228 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import search_create_params
+from .._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.search_create_response import SearchCreateResponse
+
+__all__ = ["SearchResource", "AsyncSearchResource"]
+
+
+class SearchResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> SearchResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/perplexityai/perplexity-py#accessing-raw-response-data-eg-headers
+        """
+        return SearchResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SearchResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/perplexityai/perplexity-py#with_streaming_response
+        """
+        return SearchResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        query: Union[str, SequenceNotStr[str]],
+        country: Optional[str] | Omit = omit,
+        display_server_time: bool | Omit = omit,
+        last_updated_after_filter: Optional[str] | Omit = omit,
+        last_updated_before_filter: Optional[str] | Omit = omit,
+        max_results: int | Omit = omit,
+        max_tokens: int | Omit = omit,
+        max_tokens_per_page: int | Omit = omit,
+        search_after_date_filter: Optional[str] | Omit = omit,
+        search_before_date_filter: Optional[str] | Omit = omit,
+        search_domain_filter: Optional[SequenceNotStr[str]] | Omit = omit,
+        search_language_filter: Optional[SequenceNotStr[str]] | Omit = omit,
+        search_mode: Optional[Literal["web", "academic", "sec"]] | Omit = omit,
+        search_recency_filter: Optional[Literal["hour", "day", "week", "month", "year"]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SearchCreateResponse:
+        """
+        Search the web and retrieve relevant web page contents.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/search",
+            body=maybe_transform(
+                {
+                    "query": query,
+                    "country": country,
+                    "display_server_time": display_server_time,
+                    "last_updated_after_filter": last_updated_after_filter,
+                    "last_updated_before_filter": last_updated_before_filter,
+                    "max_results": max_results,
+                    "max_tokens": max_tokens,
+                    "max_tokens_per_page": max_tokens_per_page,
+                    "search_after_date_filter": search_after_date_filter,
+                    "search_before_date_filter": search_before_date_filter,
+                    "search_domain_filter": search_domain_filter,
+                    "search_language_filter": search_language_filter,
+                    "search_mode": search_mode,
+                    "search_recency_filter": search_recency_filter,
+                },
+                search_create_params.SearchCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchCreateResponse,
+        )
+
+
+class AsyncSearchResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncSearchResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/perplexityai/perplexity-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncSearchResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSearchResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/perplexityai/perplexity-py#with_streaming_response
+        """
+        return AsyncSearchResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        query: Union[str, SequenceNotStr[str]],
+        country: Optional[str] | Omit = omit,
+        display_server_time: bool | Omit = omit,
+        last_updated_after_filter: Optional[str] | Omit = omit,
+        last_updated_before_filter: Optional[str] | Omit = omit,
+        max_results: int | Omit = omit,
+        max_tokens: int | Omit = omit,
+        max_tokens_per_page: int | Omit = omit,
+        search_after_date_filter: Optional[str] | Omit = omit,
+        search_before_date_filter: Optional[str] | Omit = omit,
+        search_domain_filter: Optional[SequenceNotStr[str]] | Omit = omit,
+        search_language_filter: Optional[SequenceNotStr[str]] | Omit = omit,
+        search_mode: Optional[Literal["web", "academic", "sec"]] | Omit = omit,
+        search_recency_filter: Optional[Literal["hour", "day", "week", "month", "year"]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SearchCreateResponse:
+        """
+        Search the web and retrieve relevant web page contents.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/search",
+            body=await async_maybe_transform(
+                {
+                    "query": query,
+                    "country": country,
+                    "display_server_time": display_server_time,
+                    "last_updated_after_filter": last_updated_after_filter,
+                    "last_updated_before_filter": last_updated_before_filter,
+                    "max_results": max_results,
+                    "max_tokens": max_tokens,
+                    "max_tokens_per_page": max_tokens_per_page,
+                    "search_after_date_filter": search_after_date_filter,
+                    "search_before_date_filter": search_before_date_filter,
+                    "search_domain_filter": search_domain_filter,
+                    "search_language_filter": search_language_filter,
+                    "search_mode": search_mode,
+                    "search_recency_filter": search_recency_filter,
+                },
+                search_create_params.SearchCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchCreateResponse,
+        )
+
+
+class SearchResourceWithRawResponse:
+    def __init__(self, search: SearchResource) -> None:
+        self._search = search
+
+        self.create = to_raw_response_wrapper(
+            search.create,
+        )
+
+
+class AsyncSearchResourceWithRawResponse:
+    def __init__(self, search: AsyncSearchResource) -> None:
+        self._search = search
+
+        self.create = async_to_raw_response_wrapper(
+            search.create,
+        )
+
+
+class SearchResourceWithStreamingResponse:
+    def __init__(self, search: SearchResource) -> None:
+        self._search = search
+
+        self.create = to_streamed_response_wrapper(
+            search.create,
+        )
+
+
+class AsyncSearchResourceWithStreamingResponse:
+    def __init__(self, search: AsyncSearchResource) -> None:
+        self._search = search
+
+        self.create = async_to_streamed_response_wrapper(
+            search.create,
+        )

perplexity/types/__init__.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .shared import (
+    Choice as Choice,
+    UsageInfo as UsageInfo,
+    ChatMessageInput as ChatMessageInput,
+    ChatMessageOutput as ChatMessageOutput,
+    APIPublicSearchResult as APIPublicSearchResult,
+)
+from .stream_chunk import StreamChunk as StreamChunk
+from .search_create_params import SearchCreateParams as SearchCreateParams
+from .search_create_response import SearchCreateResponse as SearchCreateResponse

perplexity/types/async_/__init__.py

@@ -0,0 +1,3 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations

perplexity/types/async_/chat/__init__.py

@@ -0,0 +1,9 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .completion_get_params import CompletionGetParams as CompletionGetParams
+from .completion_get_response import CompletionGetResponse as CompletionGetResponse
+from .completion_create_params import CompletionCreateParams as CompletionCreateParams
+from .completion_list_response import CompletionListResponse as CompletionListResponse
+from .completion_create_response import CompletionCreateResponse as CompletionCreateResponse

perplexity/types/async_/chat/completion_create_params.py

@@ -0,0 +1,242 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from ...._types import SequenceNotStr
+from ...shared_params.chat_message_input import ChatMessageInput
+
+__all__ = [
+    "CompletionCreateParams",
+    "Request",
+    "RequestResponseFormat",
+    "RequestResponseFormatResponseFormatText",
+    "RequestResponseFormatResponseFormatJsonSchema",
+    "RequestResponseFormatResponseFormatJsonSchemaJsonSchema",
+    "RequestResponseFormatResponseFormatRegex",
+    "RequestResponseFormatResponseFormatRegexRegex",
+    "RequestTool",
+    "RequestToolFunction",
+    "RequestToolFunctionParameters",
+    "RequestWebSearchOptions",
+    "RequestWebSearchOptionsUserLocation",
+]
+
+
+class CompletionCreateParams(TypedDict, total=False):
+    request: Required[Request]
+
+    idempotency_key: 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]
+
+    latitude: Optional[float]
+
+    longitude: Optional[float]
+
+    region: Optional[str]
+
+
+class RequestWebSearchOptions(TypedDict, total=False):
+    image_results_enhanced_relevance: bool
+
+    search_context_size: Literal["low", "medium", "high"]
+
+    search_type: Optional[Literal["fast", "pro", "auto"]]
+
+    user_location: Optional[RequestWebSearchOptionsUserLocation]
+
+
+class Request(TypedDict, total=False):
+    messages: Required[Iterable[ChatMessageInput]]
+
+    model: Required[str]
+
+    _debug_pro_search: bool
+
+    _force_new_agent: Optional[bool]
+
+    _inputs: Optional[Iterable[int]]
+
+    _prompt_token_length: Optional[int]
+
+    best_of: Optional[int]
+
+    country: Optional[str]
+
+    cum_logprobs: Optional[bool]
+
+    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]]
+
+    language_preference: Optional[str]
+
+    last_updated_after_filter: Optional[str]
+
+    last_updated_before_filter: Optional[str]
+
+    latitude: Optional[float]
+
+    logprobs: Optional[bool]
+
+    longitude: Optional[float]
+
+    max_tokens: Optional[int]
+
+    n: Optional[int]
+
+    num_images: int
+
+    num_search_results: int
+
+    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]
+
+    search_before_date_filter: Optional[str]
+
+    search_domain_filter: Optional[SequenceNotStr[str]]
+
+    search_internal_properties: Optional[Dict[str, object]]
+
+    search_language_filter: Optional[SequenceNotStr[str]]
+
+    search_mode: Optional[Literal["web", "academic", "sec"]]
+
+    search_recency_filter: Optional[Literal["hour", "day", "week", "month", "year"]]
+
+    search_tenant: Optional[str]
+
+    stop: Union[str, SequenceNotStr[str], None]
+
+    stream: Optional[bool]
+
+    stream_mode: Literal["full", "concise"]
+
+    temperature: Optional[float]
+
+    thread_id: Optional[str]
+
+    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]
+
+    use_threads: Optional[bool]
+
+    user_original_query: Optional[str]
+
+    web_search_options: RequestWebSearchOptions

perplexity/types/async_/chat/completion_create_response.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+from ...stream_chunk import StreamChunk
+
+__all__ = ["CompletionCreateResponse"]
+
+
+class CompletionCreateResponse(BaseModel):
+    id: str
+
+    created_at: int
+
+    model: str
+
+    status: Literal["CREATED", "IN_PROGRESS", "COMPLETED", "FAILED"]
+    """Status enum for async processing."""
+
+    completed_at: Optional[int] = None
+
+    error_message: Optional[str] = None
+
+    failed_at: Optional[int] = None
+
+    response: Optional[StreamChunk] = None
+
+    started_at: Optional[int] = None

perplexity/types/async_/chat/completion_get_params.py

@@ -0,0 +1,25 @@
+# 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_created_at_epoch_seconds: Annotated[str, PropertyInfo(alias="x-created-at-epoch-seconds")]
+
+    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

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+from ...stream_chunk import StreamChunk
+
+__all__ = ["CompletionGetResponse"]
+
+
+class CompletionGetResponse(BaseModel):
+    id: str
+
+    created_at: int
+
+    model: str
+
+    status: Literal["CREATED", "IN_PROGRESS", "COMPLETED", "FAILED"]
+    """Status enum for async processing."""
+
+    completed_at: Optional[int] = None
+
+    error_message: Optional[str] = None
+
+    failed_at: Optional[int] = None
+
+    response: Optional[StreamChunk] = None
+
+    started_at: Optional[int] = None

perplexity/types/async_/chat/completion_list_response.py

@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["CompletionListResponse", "Request"]
+
+
+class Request(BaseModel):
+    id: str
+
+    created_at: int
+
+    model: str
+
+    status: Literal["CREATED", "IN_PROGRESS", "COMPLETED", "FAILED"]
+    """Status enum for async processing."""
+
+    completed_at: Optional[int] = None
+
+    failed_at: Optional[int] = None
+
+    started_at: Optional[int] = None
+
+
+class CompletionListResponse(BaseModel):
+    requests: List[Request]
+
+    next_token: Optional[str] = None

perplexity/types/chat/__init__.py

@@ -0,0 +1,5 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .completion_create_params import CompletionCreateParams as CompletionCreateParams