feat(api): manual updates

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
-configured_endpoints: 18
+configured_endpoints: 19
 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-ebd5e757d0e76cb83013e01a1e0bb3dba62beb83b2a2ffa28d148ea032e96fd0.yml
 openapi_spec_hash: f930474a6ad230545154244045cc602e
-config_hash: 2113359488acead9b94556d37765c57e
+config_hash: 23f1770611dec274363355d52f3918cc

api.md

@@ -1,3 +1,15 @@
+# Supermemory
+
+Types:
+
+```python
+from supermemory.types import ProfileResponse
+```
+
+Methods:
+
+- <code title="post /v4/profile">client.<a href="./src/supermemory/_client.py">profile</a>(\*\*<a href="src/supermemory/types/client_profile_params.py">params</a>) -> <a href="./src/supermemory/types/profile_response.py">ProfileResponse</a></code>
+
 # Memories
 
 Types:

src/supermemory/_client.py

@@ -10,25 +10,43 @@
 
 from . import _exceptions
 from ._qs import Querystring
+from .types import client_profile_params
 from ._types import (
+    Body,
     Omit,
+    Query,
+    Headers,
     Timeout,
     NotGiven,
     Transport,
     ProxiesTypes,
     RequestOptions,
+    omit,
     not_given,
 )
-from ._utils import is_given, get_async_library
+from ._utils import (
+    is_given,
+    maybe_transform,
+    get_async_library,
+    async_maybe_transform,
+)
 from ._version import __version__
+from ._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
 from .resources import search, memories, settings, documents, connections
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, SupermemoryError
 from ._base_client import (
     DEFAULT_MAX_RETRIES,
     SyncAPIClient,
     AsyncAPIClient,
+    make_request_options,
 )
+from .types.profile_response import ProfileResponse
 
 __all__ = [
     "Timeout",
@@ -184,6 +202,50 @@ def copy(
     # client.with_options(timeout=10).foo.create(...)
     with_options = copy
 
+    def profile(
+        self,
+        *,
+        container_tag: str,
+        q: str | 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,
+    ) -> ProfileResponse:
+        """
+        Get user profile with optional search results
+
+        Args:
+          container_tag: Tag to filter the profile by. This can be an ID for your user, a project ID, or
+              any other identifier you wish to use to filter memories.
+
+          q: Optional search query to include search results in the response
+
+          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(
+            "/v4/profile",
+            body=maybe_transform(
+                {
+                    "container_tag": container_tag,
+                    "q": q,
+                },
+                client_profile_params.ClientProfileParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ProfileResponse,
+        )
+
     @override
     def _make_status_error(
         self,
@@ -360,6 +422,50 @@ def copy(
     # client.with_options(timeout=10).foo.create(...)
     with_options = copy
 
+    async def profile(
+        self,
+        *,
+        container_tag: str,
+        q: str | 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,
+    ) -> ProfileResponse:
+        """
+        Get user profile with optional search results
+
+        Args:
+          container_tag: Tag to filter the profile by. This can be an ID for your user, a project ID, or
+              any other identifier you wish to use to filter memories.
+
+          q: Optional search query to include search results in the response
+
+          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(
+            "/v4/profile",
+            body=await async_maybe_transform(
+                {
+                    "container_tag": container_tag,
+                    "q": q,
+                },
+                client_profile_params.ClientProfileParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ProfileResponse,
+        )
+
     @override
     def _make_status_error(
         self,
@@ -402,6 +508,10 @@ def __init__(self, client: Supermemory) -> None:
         self.settings = settings.SettingsResourceWithRawResponse(client.settings)
         self.connections = connections.ConnectionsResourceWithRawResponse(client.connections)
 
+        self.profile = to_raw_response_wrapper(
+            client.profile,
+        )
+
 
 class AsyncSupermemoryWithRawResponse:
     def __init__(self, client: AsyncSupermemory) -> None:
@@ -411,6 +521,10 @@ def __init__(self, client: AsyncSupermemory) -> None:
         self.settings = settings.AsyncSettingsResourceWithRawResponse(client.settings)
         self.connections = connections.AsyncConnectionsResourceWithRawResponse(client.connections)
 
+        self.profile = async_to_raw_response_wrapper(
+            client.profile,
+        )
+
 
 class SupermemoryWithStreamedResponse:
     def __init__(self, client: Supermemory) -> None:
@@ -420,6 +534,10 @@ def __init__(self, client: Supermemory) -> None:
         self.settings = settings.SettingsResourceWithStreamingResponse(client.settings)
         self.connections = connections.ConnectionsResourceWithStreamingResponse(client.connections)
 
+        self.profile = to_streamed_response_wrapper(
+            client.profile,
+        )
+
 
 class AsyncSupermemoryWithStreamedResponse:
     def __init__(self, client: AsyncSupermemory) -> None:
@@ -429,6 +547,10 @@ def __init__(self, client: AsyncSupermemory) -> None:
         self.settings = settings.AsyncSettingsResourceWithStreamingResponse(client.settings)
         self.connections = connections.AsyncConnectionsResourceWithStreamingResponse(client.connections)
 
+        self.profile = async_to_streamed_response_wrapper(
+            client.profile,
+        )
+
 
 Client = Supermemory
 

src/supermemory/types/__init__.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from .profile_response import ProfileResponse as ProfileResponse
 from .memory_add_params import MemoryAddParams as MemoryAddParams
 from .memory_list_params import MemoryListParams as MemoryListParams
 from .document_add_params import DocumentAddParams as DocumentAddParams
@@ -11,6 +12,7 @@
 from .memory_list_response import MemoryListResponse as MemoryListResponse
 from .memory_update_params import MemoryUpdateParams as MemoryUpdateParams
 from .setting_get_response import SettingGetResponse as SettingGetResponse
+from .client_profile_params import ClientProfileParams as ClientProfileParams
 from .document_add_response import DocumentAddResponse as DocumentAddResponse
 from .document_get_response import DocumentGetResponse as DocumentGetResponse
 from .search_execute_params import SearchExecuteParams as SearchExecuteParams

src/supermemory/types/client_profile_params.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["ClientProfileParams"]
+
+
+class ClientProfileParams(TypedDict, total=False):
+    container_tag: Required[Annotated[str, PropertyInfo(alias="containerTag")]]
+    """Tag to filter the profile by.
+
+    This can be an ID for your user, a project ID, or any other identifier you wish
+    to use to filter memories.
+    """
+
+    q: str
+    """Optional search query to include search results in the response"""

src/supermemory/types/profile_response.py

@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["ProfileResponse", "Profile", "SearchResults"]
+
+
+class Profile(BaseModel):
+    dynamic: List[str]
+    """Dynamic profile information (recent memories)"""
+
+    static: List[str]
+    """Static profile information that remains relevant long-term"""
+
+
+class SearchResults(BaseModel):
+    results: List[object]
+    """Search results for the provided query"""
+
+    timing: float
+    """Search timing in milliseconds"""
+
+    total: float
+    """Total number of search results"""
+
+
+class ProfileResponse(BaseModel):
+    profile: Profile
+
+    search_results: Optional[SearchResults] = FieldInfo(alias="searchResults", default=None)
+    """Search results if a search query was provided"""

tests/api_resources/test_client.py

@@ -0,0 +1,110 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from supermemory import Supermemory, AsyncSupermemory
+from tests.utils import assert_matches_type
+from supermemory.types import ProfileResponse
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestClient:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    def test_method_profile(self, client: Supermemory) -> None:
+        client_ = client.profile(
+            container_tag="containerTag",
+        )
+        assert_matches_type(ProfileResponse, client_, path=["response"])
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    def test_method_profile_with_all_params(self, client: Supermemory) -> None:
+        client_ = client.profile(
+            container_tag="containerTag",
+            q="q",
+        )
+        assert_matches_type(ProfileResponse, client_, path=["response"])
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    def test_raw_response_profile(self, client: Supermemory) -> None:
+        response = client.with_raw_response.profile(
+            container_tag="containerTag",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        client_ = response.parse()
+        assert_matches_type(ProfileResponse, client_, path=["response"])
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    def test_streaming_response_profile(self, client: Supermemory) -> None:
+        with client.with_streaming_response.profile(
+            container_tag="containerTag",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            client_ = response.parse()
+            assert_matches_type(ProfileResponse, client_, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+
+class TestAsyncClient:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    async def test_method_profile(self, async_client: AsyncSupermemory) -> None:
+        client = await async_client.profile(
+            container_tag="containerTag",
+        )
+        assert_matches_type(ProfileResponse, client, path=["response"])
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    async def test_method_profile_with_all_params(self, async_client: AsyncSupermemory) -> None:
+        client = await async_client.profile(
+            container_tag="containerTag",
+            q="q",
+        )
+        assert_matches_type(ProfileResponse, client, path=["response"])
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    async def test_raw_response_profile(self, async_client: AsyncSupermemory) -> None:
+        response = await async_client.with_raw_response.profile(
+            container_tag="containerTag",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        client = await response.parse()
+        assert_matches_type(ProfileResponse, client, path=["response"])
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    async def test_streaming_response_profile(self, async_client: AsyncSupermemory) -> None:
+        async with async_client.with_streaming_response.profile(
+            container_tag="containerTag",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            client = await response.parse()
+            assert_matches_type(ProfileResponse, client, path=["response"])
+
+        assert cast(Any, response.is_closed) is True