perplexityai 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

perplexity/_client.py

@@ -21,7 +21,7 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import search
+from .resources import search, content
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, PerplexityError
 from ._base_client import (
@@ -29,6 +29,8 @@ from ._base_client import (
     SyncAPIClient,
     AsyncAPIClient,
 )
+from .resources.chat import chat
+from .resources.async_ import async_
 
 __all__ = [
     "Timeout",
@@ -43,7 +45,10 @@ __all__ = [
 
 
 class Perplexity(SyncAPIClient):
+    chat: chat.ChatResource
+    async_: async_.AsyncResource
     search: search.SearchResource
+    content: content.ContentResource
     with_raw_response: PerplexityWithRawResponse
     with_streaming_response: PerplexityWithStreamedResponse
 
@@ -101,7 +106,10 @@ class Perplexity(SyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
+        self.chat = chat.ChatResource(self)
+        self.async_ = async_.AsyncResource(self)
         self.search = search.SearchResource(self)
+        self.content = content.ContentResource(self)
         self.with_raw_response = PerplexityWithRawResponse(self)
         self.with_streaming_response = PerplexityWithStreamedResponse(self)
 
@@ -211,7 +219,10 @@ class Perplexity(SyncAPIClient):
 
 
 class AsyncPerplexity(AsyncAPIClient):
+    chat: chat.AsyncChatResource
+    async_: async_.AsyncAsyncResource
     search: search.AsyncSearchResource
+    content: content.AsyncContentResource
     with_raw_response: AsyncPerplexityWithRawResponse
     with_streaming_response: AsyncPerplexityWithStreamedResponse
 
@@ -269,7 +280,10 @@ class AsyncPerplexity(AsyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
+        self.chat = chat.AsyncChatResource(self)
+        self.async_ = async_.AsyncAsyncResource(self)
         self.search = search.AsyncSearchResource(self)
+        self.content = content.AsyncContentResource(self)
         self.with_raw_response = AsyncPerplexityWithRawResponse(self)
         self.with_streaming_response = AsyncPerplexityWithStreamedResponse(self)
 
@@ -380,22 +394,34 @@ class AsyncPerplexity(AsyncAPIClient):
 
 class PerplexityWithRawResponse:
     def __init__(self, client: Perplexity) -> None:
+        self.chat = chat.ChatResourceWithRawResponse(client.chat)
+        self.async_ = async_.AsyncResourceWithRawResponse(client.async_)
         self.search = search.SearchResourceWithRawResponse(client.search)
+        self.content = content.ContentResourceWithRawResponse(client.content)
 
 
 class AsyncPerplexityWithRawResponse:
     def __init__(self, client: AsyncPerplexity) -> None:
+        self.chat = chat.AsyncChatResourceWithRawResponse(client.chat)
+        self.async_ = async_.AsyncAsyncResourceWithRawResponse(client.async_)
         self.search = search.AsyncSearchResourceWithRawResponse(client.search)
+        self.content = content.AsyncContentResourceWithRawResponse(client.content)
 
 
 class PerplexityWithStreamedResponse:
     def __init__(self, client: Perplexity) -> None:
+        self.chat = chat.ChatResourceWithStreamingResponse(client.chat)
+        self.async_ = async_.AsyncResourceWithStreamingResponse(client.async_)
         self.search = search.SearchResourceWithStreamingResponse(client.search)
+        self.content = content.ContentResourceWithStreamingResponse(client.content)
 
 
 class AsyncPerplexityWithStreamedResponse:
     def __init__(self, client: AsyncPerplexity) -> None:
+        self.chat = chat.AsyncChatResourceWithStreamingResponse(client.chat)
+        self.async_ = async_.AsyncAsyncResourceWithStreamingResponse(client.async_)
         self.search = search.AsyncSearchResourceWithStreamingResponse(client.search)
+        self.content = content.AsyncContentResourceWithStreamingResponse(client.content)
 
 
 Client = Perplexity

perplexity/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "perplexity"
-__version__ = "0.5.0"  # x-release-please-version
+__version__ = "0.7.0"  # x-release-please-version

perplexity/resources/__init__.py

@@ -1,5 +1,21 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .chat import (
+    ChatResource,
+    AsyncChatResource,
+    ChatResourceWithRawResponse,
+    AsyncChatResourceWithRawResponse,
+    ChatResourceWithStreamingResponse,
+    AsyncChatResourceWithStreamingResponse,
+)
+from .async_ import (
+    AsyncResource,
+    AsyncAsyncResource,
+    AsyncResourceWithRawResponse,
+    AsyncAsyncResourceWithRawResponse,
+    AsyncResourceWithStreamingResponse,
+    AsyncAsyncResourceWithStreamingResponse,
+)
 from .search import (
     SearchResource,
     AsyncSearchResource,
@@ -8,12 +24,38 @@ from .search import (
     SearchResourceWithStreamingResponse,
     AsyncSearchResourceWithStreamingResponse,
 )
+from .content import (
+    ContentResource,
+    AsyncContentResource,
+    ContentResourceWithRawResponse,
+    AsyncContentResourceWithRawResponse,
+    ContentResourceWithStreamingResponse,
+    AsyncContentResourceWithStreamingResponse,
+)
 
 __all__ = [
+    "ChatResource",
+    "AsyncChatResource",
+    "ChatResourceWithRawResponse",
+    "AsyncChatResourceWithRawResponse",
+    "ChatResourceWithStreamingResponse",
+    "AsyncChatResourceWithStreamingResponse",
+    "AsyncResource",
+    "AsyncAsyncResource",
+    "AsyncResourceWithRawResponse",
+    "AsyncAsyncResourceWithRawResponse",
+    "AsyncResourceWithStreamingResponse",
+    "AsyncAsyncResourceWithStreamingResponse",
     "SearchResource",
     "AsyncSearchResource",
     "SearchResourceWithRawResponse",
     "AsyncSearchResourceWithRawResponse",
     "SearchResourceWithStreamingResponse",
     "AsyncSearchResourceWithStreamingResponse",
+    "ContentResource",
+    "AsyncContentResource",
+    "ContentResourceWithRawResponse",
+    "AsyncContentResourceWithRawResponse",
+    "ContentResourceWithStreamingResponse",
+    "AsyncContentResourceWithStreamingResponse",
 ]

perplexity/resources/async_/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .chat import (
+    ChatResource,
+    AsyncChatResource,
+    ChatResourceWithRawResponse,
+    AsyncChatResourceWithRawResponse,
+    ChatResourceWithStreamingResponse,
+    AsyncChatResourceWithStreamingResponse,
+)
+from .async_ import (
+    AsyncResource,
+    AsyncAsyncResource,
+    AsyncResourceWithRawResponse,
+    AsyncAsyncResourceWithRawResponse,
+    AsyncResourceWithStreamingResponse,
+    AsyncAsyncResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "ChatResource",
+    "AsyncChatResource",
+    "ChatResourceWithRawResponse",
+    "AsyncChatResourceWithRawResponse",
+    "ChatResourceWithStreamingResponse",
+    "AsyncChatResourceWithStreamingResponse",
+    "AsyncResource",
+    "AsyncAsyncResource",
+    "AsyncResourceWithRawResponse",
+    "AsyncAsyncResourceWithRawResponse",
+    "AsyncResourceWithStreamingResponse",
+    "AsyncAsyncResourceWithStreamingResponse",
+]

perplexity/resources/async_/async_.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from ..._compat import cached_property
+from .chat.chat import (
+    ChatResource,
+    AsyncChatResource,
+    ChatResourceWithRawResponse,
+    AsyncChatResourceWithRawResponse,
+    ChatResourceWithStreamingResponse,
+    AsyncChatResourceWithStreamingResponse,
+)
+from ..._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["AsyncResource", "AsyncAsyncResource"]
+
+
+class AsyncResource(SyncAPIResource):
+    @cached_property
+    def chat(self) -> ChatResource:
+        return ChatResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncResourceWithRawResponse:
+        """
+        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/ppl-ai/perplexity-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/ppl-ai/perplexity-py#with_streaming_response
+        """
+        return AsyncResourceWithStreamingResponse(self)
+
+
+class AsyncAsyncResource(AsyncAPIResource):
+    @cached_property
+    def chat(self) -> AsyncChatResource:
+        return AsyncChatResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncAsyncResourceWithRawResponse:
+        """
+        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/ppl-ai/perplexity-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncAsyncResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncAsyncResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/ppl-ai/perplexity-py#with_streaming_response
+        """
+        return AsyncAsyncResourceWithStreamingResponse(self)
+
+
+class AsyncResourceWithRawResponse:
+    def __init__(self, async_: AsyncResource) -> None:
+        self._async_ = async_
+
+    @cached_property
+    def chat(self) -> ChatResourceWithRawResponse:
+        return ChatResourceWithRawResponse(self._async_.chat)
+
+
+class AsyncAsyncResourceWithRawResponse:
+    def __init__(self, async_: AsyncAsyncResource) -> None:
+        self._async_ = async_
+
+    @cached_property
+    def chat(self) -> AsyncChatResourceWithRawResponse:
+        return AsyncChatResourceWithRawResponse(self._async_.chat)
+
+
+class AsyncResourceWithStreamingResponse:
+    def __init__(self, async_: AsyncResource) -> None:
+        self._async_ = async_
+
+    @cached_property
+    def chat(self) -> ChatResourceWithStreamingResponse:
+        return ChatResourceWithStreamingResponse(self._async_.chat)
+
+
+class AsyncAsyncResourceWithStreamingResponse:
+    def __init__(self, async_: AsyncAsyncResource) -> None:
+        self._async_ = async_
+
+    @cached_property
+    def chat(self) -> AsyncChatResourceWithStreamingResponse:
+        return AsyncChatResourceWithStreamingResponse(self._async_.chat)

perplexity/resources/async_/chat/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .chat import (
+    ChatResource,
+    AsyncChatResource,
+    ChatResourceWithRawResponse,
+    AsyncChatResourceWithRawResponse,
+    ChatResourceWithStreamingResponse,
+    AsyncChatResourceWithStreamingResponse,
+)
+from .completions import (
+    CompletionsResource,
+    AsyncCompletionsResource,
+    CompletionsResourceWithRawResponse,
+    AsyncCompletionsResourceWithRawResponse,
+    CompletionsResourceWithStreamingResponse,
+    AsyncCompletionsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "CompletionsResource",
+    "AsyncCompletionsResource",
+    "CompletionsResourceWithRawResponse",
+    "AsyncCompletionsResourceWithRawResponse",
+    "CompletionsResourceWithStreamingResponse",
+    "AsyncCompletionsResourceWithStreamingResponse",
+    "ChatResource",
+    "AsyncChatResource",
+    "ChatResourceWithRawResponse",
+    "AsyncChatResourceWithRawResponse",
+    "ChatResourceWithStreamingResponse",
+    "AsyncChatResourceWithStreamingResponse",
+]

perplexity/resources/async_/chat/chat.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from ...._compat import cached_property
+from .completions import (
+    CompletionsResource,
+    AsyncCompletionsResource,
+    CompletionsResourceWithRawResponse,
+    AsyncCompletionsResourceWithRawResponse,
+    CompletionsResourceWithStreamingResponse,
+    AsyncCompletionsResourceWithStreamingResponse,
+)
+from ...._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["ChatResource", "AsyncChatResource"]
+
+
+class ChatResource(SyncAPIResource):
+    @cached_property
+    def completions(self) -> CompletionsResource:
+        return CompletionsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> ChatResourceWithRawResponse:
+        """
+        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/ppl-ai/perplexity-py#accessing-raw-response-data-eg-headers
+        """
+        return ChatResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ChatResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/ppl-ai/perplexity-py#with_streaming_response
+        """
+        return ChatResourceWithStreamingResponse(self)
+
+
+class AsyncChatResource(AsyncAPIResource):
+    @cached_property
+    def completions(self) -> AsyncCompletionsResource:
+        return AsyncCompletionsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncChatResourceWithRawResponse:
+        """
+        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/ppl-ai/perplexity-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncChatResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncChatResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/ppl-ai/perplexity-py#with_streaming_response
+        """
+        return AsyncChatResourceWithStreamingResponse(self)
+
+
+class ChatResourceWithRawResponse:
+    def __init__(self, chat: ChatResource) -> None:
+        self._chat = chat
+
+    @cached_property
+    def completions(self) -> CompletionsResourceWithRawResponse:
+        return CompletionsResourceWithRawResponse(self._chat.completions)
+
+
+class AsyncChatResourceWithRawResponse:
+    def __init__(self, chat: AsyncChatResource) -> None:
+        self._chat = chat
+
+    @cached_property
+    def completions(self) -> AsyncCompletionsResourceWithRawResponse:
+        return AsyncCompletionsResourceWithRawResponse(self._chat.completions)
+
+
+class ChatResourceWithStreamingResponse:
+    def __init__(self, chat: ChatResource) -> None:
+        self._chat = chat
+
+    @cached_property
+    def completions(self) -> CompletionsResourceWithStreamingResponse:
+        return CompletionsResourceWithStreamingResponse(self._chat.completions)
+
+
+class AsyncChatResourceWithStreamingResponse:
+    def __init__(self, chat: AsyncChatResource) -> None:
+        self._chat = chat
+
+    @cached_property
+    def completions(self) -> AsyncCompletionsResourceWithStreamingResponse:
+        return AsyncCompletionsResourceWithStreamingResponse(self._chat.completions)