supermemory 0.1.0a1__py3-none-any.whl

supermemory/resources/search.py

@@ -0,0 +1,254 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import search_execute_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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_execute_response import SearchExecuteResponse
+
+__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/supermemoryai/python-sdk#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/supermemoryai/python-sdk#with_streaming_response
+        """
+        return SearchResourceWithStreamingResponse(self)
+
+    def execute(
+        self,
+        *,
+        q: str,
+        categories_filter: List[Literal["technology", "science", "business", "health"]] | NotGiven = NOT_GIVEN,
+        chunk_threshold: float | NotGiven = NOT_GIVEN,
+        doc_id: str | NotGiven = NOT_GIVEN,
+        document_threshold: float | NotGiven = NOT_GIVEN,
+        filters: search_execute_params.Filters | NotGiven = NOT_GIVEN,
+        include_summary: bool | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        only_matching_chunks: bool | NotGiven = NOT_GIVEN,
+        user_id: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> SearchExecuteResponse:
+        """
+        Search through documents with metadata filtering
+
+        Args:
+          q: Search query string
+
+          categories_filter: Optional category filters
+
+          chunk_threshold: Maximum number of chunks to return
+
+          doc_id: Optional document ID to search within
+
+          document_threshold: Maximum number of documents to return
+
+          filters: Optional filters to apply to the search
+
+          include_summary: If true, include document summary in the response. This is helpful if you want a
+              chatbot to know the context of the document.
+
+          limit: Maximum number of results to return
+
+          only_matching_chunks: If true, only return matching chunks without context
+
+          user_id: End user ID this search is associated with
+
+          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(
+                {
+                    "q": q,
+                    "categories_filter": categories_filter,
+                    "chunk_threshold": chunk_threshold,
+                    "doc_id": doc_id,
+                    "document_threshold": document_threshold,
+                    "filters": filters,
+                    "include_summary": include_summary,
+                    "limit": limit,
+                    "only_matching_chunks": only_matching_chunks,
+                    "user_id": user_id,
+                },
+                search_execute_params.SearchExecuteParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchExecuteResponse,
+        )
+
+
+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/supermemoryai/python-sdk#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/supermemoryai/python-sdk#with_streaming_response
+        """
+        return AsyncSearchResourceWithStreamingResponse(self)
+
+    async def execute(
+        self,
+        *,
+        q: str,
+        categories_filter: List[Literal["technology", "science", "business", "health"]] | NotGiven = NOT_GIVEN,
+        chunk_threshold: float | NotGiven = NOT_GIVEN,
+        doc_id: str | NotGiven = NOT_GIVEN,
+        document_threshold: float | NotGiven = NOT_GIVEN,
+        filters: search_execute_params.Filters | NotGiven = NOT_GIVEN,
+        include_summary: bool | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        only_matching_chunks: bool | NotGiven = NOT_GIVEN,
+        user_id: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> SearchExecuteResponse:
+        """
+        Search through documents with metadata filtering
+
+        Args:
+          q: Search query string
+
+          categories_filter: Optional category filters
+
+          chunk_threshold: Maximum number of chunks to return
+
+          doc_id: Optional document ID to search within
+
+          document_threshold: Maximum number of documents to return
+
+          filters: Optional filters to apply to the search
+
+          include_summary: If true, include document summary in the response. This is helpful if you want a
+              chatbot to know the context of the document.
+
+          limit: Maximum number of results to return
+
+          only_matching_chunks: If true, only return matching chunks without context
+
+          user_id: End user ID this search is associated with
+
+          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(
+                {
+                    "q": q,
+                    "categories_filter": categories_filter,
+                    "chunk_threshold": chunk_threshold,
+                    "doc_id": doc_id,
+                    "document_threshold": document_threshold,
+                    "filters": filters,
+                    "include_summary": include_summary,
+                    "limit": limit,
+                    "only_matching_chunks": only_matching_chunks,
+                    "user_id": user_id,
+                },
+                search_execute_params.SearchExecuteParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchExecuteResponse,
+        )
+
+
+class SearchResourceWithRawResponse:
+    def __init__(self, search: SearchResource) -> None:
+        self._search = search
+
+        self.execute = to_raw_response_wrapper(
+            search.execute,
+        )
+
+
+class AsyncSearchResourceWithRawResponse:
+    def __init__(self, search: AsyncSearchResource) -> None:
+        self._search = search
+
+        self.execute = async_to_raw_response_wrapper(
+            search.execute,
+        )
+
+
+class SearchResourceWithStreamingResponse:
+    def __init__(self, search: SearchResource) -> None:
+        self._search = search
+
+        self.execute = to_streamed_response_wrapper(
+            search.execute,
+        )
+
+
+class AsyncSearchResourceWithStreamingResponse:
+    def __init__(self, search: AsyncSearchResource) -> None:
+        self._search = search
+
+        self.execute = async_to_streamed_response_wrapper(
+            search.execute,
+        )

supermemory/resources/settings.py

@@ -0,0 +1,195 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Iterable
+
+import httpx
+
+from ..types import setting_update_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.setting_update_response import SettingUpdateResponse
+
+__all__ = ["SettingsResource", "AsyncSettingsResource"]
+
+
+class SettingsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> SettingsResourceWithRawResponse:
+        """
+        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/supermemoryai/python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return SettingsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SettingsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/supermemoryai/python-sdk#with_streaming_response
+        """
+        return SettingsResourceWithStreamingResponse(self)
+
+    def update(
+        self,
+        *,
+        categories: List[str] | NotGiven = NOT_GIVEN,
+        exclude_items: List[str] | NotGiven = NOT_GIVEN,
+        filter_prompt: str | NotGiven = NOT_GIVEN,
+        filter_tags: Iterable[setting_update_params.FilterTag] | NotGiven = NOT_GIVEN,
+        include_items: List[str] | NotGiven = NOT_GIVEN,
+        should_llm_filter: bool | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> SettingUpdateResponse:
+        """
+        Update settings for an organization
+
+        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._put(
+            "/settings",
+            body=maybe_transform(
+                {
+                    "categories": categories,
+                    "exclude_items": exclude_items,
+                    "filter_prompt": filter_prompt,
+                    "filter_tags": filter_tags,
+                    "include_items": include_items,
+                    "should_llm_filter": should_llm_filter,
+                },
+                setting_update_params.SettingUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SettingUpdateResponse,
+        )
+
+
+class AsyncSettingsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncSettingsResourceWithRawResponse:
+        """
+        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/supermemoryai/python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return AsyncSettingsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSettingsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/supermemoryai/python-sdk#with_streaming_response
+        """
+        return AsyncSettingsResourceWithStreamingResponse(self)
+
+    async def update(
+        self,
+        *,
+        categories: List[str] | NotGiven = NOT_GIVEN,
+        exclude_items: List[str] | NotGiven = NOT_GIVEN,
+        filter_prompt: str | NotGiven = NOT_GIVEN,
+        filter_tags: Iterable[setting_update_params.FilterTag] | NotGiven = NOT_GIVEN,
+        include_items: List[str] | NotGiven = NOT_GIVEN,
+        should_llm_filter: bool | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> SettingUpdateResponse:
+        """
+        Update settings for an organization
+
+        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._put(
+            "/settings",
+            body=await async_maybe_transform(
+                {
+                    "categories": categories,
+                    "exclude_items": exclude_items,
+                    "filter_prompt": filter_prompt,
+                    "filter_tags": filter_tags,
+                    "include_items": include_items,
+                    "should_llm_filter": should_llm_filter,
+                },
+                setting_update_params.SettingUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SettingUpdateResponse,
+        )
+
+
+class SettingsResourceWithRawResponse:
+    def __init__(self, settings: SettingsResource) -> None:
+        self._settings = settings
+
+        self.update = to_raw_response_wrapper(
+            settings.update,
+        )
+
+
+class AsyncSettingsResourceWithRawResponse:
+    def __init__(self, settings: AsyncSettingsResource) -> None:
+        self._settings = settings
+
+        self.update = async_to_raw_response_wrapper(
+            settings.update,
+        )
+
+
+class SettingsResourceWithStreamingResponse:
+    def __init__(self, settings: SettingsResource) -> None:
+        self._settings = settings
+
+        self.update = to_streamed_response_wrapper(
+            settings.update,
+        )
+
+
+class AsyncSettingsResourceWithStreamingResponse:
+    def __init__(self, settings: AsyncSettingsResource) -> None:
+        self._settings = settings
+
+        self.update = async_to_streamed_response_wrapper(
+            settings.update,
+        )

supermemory/types/__init__.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .memory_list_params import MemoryListParams as MemoryListParams
+from .memory_get_response import MemoryGetResponse as MemoryGetResponse
+from .memory_create_params import MemoryCreateParams as MemoryCreateParams
+from .memory_list_response import MemoryListResponse as MemoryListResponse
+from .search_execute_params import SearchExecuteParams as SearchExecuteParams
+from .setting_update_params import SettingUpdateParams as SettingUpdateParams
+from .memory_create_response import MemoryCreateResponse as MemoryCreateResponse
+from .memory_delete_response import MemoryDeleteResponse as MemoryDeleteResponse
+from .search_execute_response import SearchExecuteResponse as SearchExecuteResponse
+from .setting_update_response import SettingUpdateResponse as SettingUpdateResponse
+from .connection_create_params import ConnectionCreateParams as ConnectionCreateParams
+from .connection_create_response import ConnectionCreateResponse as ConnectionCreateResponse

supermemory/types/connection_create_params.py

@@ -0,0 +1,15 @@
+# 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__ = ["ConnectionCreateParams"]
+
+
+class ConnectionCreateParams(TypedDict, total=False):
+    id: Required[str]
+
+    redirect_url: Annotated[str, PropertyInfo(alias="redirectUrl")]

supermemory/types/connection_create_response.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["ConnectionCreateResponse"]
+
+
+class ConnectionCreateResponse(BaseModel):
+    expires_in: str = FieldInfo(alias="expiresIn")
+
+    magic_link: str = FieldInfo(alias="magicLink")

supermemory/types/memory_create_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 import Dict, Union
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["MemoryCreateParams"]
+
+
+class MemoryCreateParams(TypedDict, total=False):
+    content: Required[str]
+    """Content of the memory"""
+
+    id: str
+
+    metadata: Dict[str, Union[str, float, bool]]
+    """Optional metadata for the memory"""
+
+    user_id: Annotated[str, PropertyInfo(alias="userId")]
+    """Optional end user ID this memory belongs to"""

supermemory/types/memory_create_response.py

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["MemoryCreateResponse"]
+
+
+class MemoryCreateResponse(BaseModel):
+    id: str
+
+    status: str

supermemory/types/memory_delete_response.py

@@ -0,0 +1,9 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["MemoryDeleteResponse"]
+
+
+class MemoryDeleteResponse(BaseModel):
+    success: bool

supermemory/types/memory_get_response.py

@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["MemoryGetResponse", "Doc"]
+
+
+class Doc(BaseModel):
+    created_at: str = FieldInfo(alias="createdAt")
+
+    updated_at: str = FieldInfo(alias="updatedAt")
+
+    metadata: Optional[Dict[str, object]] = None
+
+    summary: Optional[str] = None
+
+    title: Optional[str] = None
+
+
+class MemoryGetResponse(BaseModel):
+    doc: Doc
+
+    status: Optional[str] = None

supermemory/types/memory_list_params.py

@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["MemoryListParams"]
+
+
+class MemoryListParams(TypedDict, total=False):
+    filters: str
+    """Optional filters to apply to the search"""
+
+    limit: str
+    """Number of items per page"""
+
+    order: Literal["asc", "desc"]
+    """Sort order"""
+
+    page: str
+    """Page number to fetch"""
+
+    sort: Literal["createdAt", "updatedAt"]
+    """Field to sort by"""

supermemory/types/memory_list_response.py

@@ -0,0 +1,59 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["MemoryListResponse", "Memory", "Pagination"]
+
+
+class Memory(BaseModel):
+    id: str
+    """Unique identifier of the memory"""
+
+    created_at: datetime = FieldInfo(alias="createdAt")
+    """Creation timestamp"""
+
+    metadata: Dict[str, object]
+    """Custom metadata associated with the memory"""
+
+    status: Optional[Literal["queued", "extracting", "chunking", "embedding", "indexing", "done", "failed"]] = None
+    """Processing status of the memory"""
+
+    summary: Optional[str] = None
+    """Summary of the memory content"""
+
+    title: str
+    """Title of the memory"""
+
+    updated_at: datetime = FieldInfo(alias="updatedAt")
+    """Last update timestamp"""
+
+    url: Optional[str] = None
+    """Source URL of the memory"""
+
+    workflow_status: Optional[Literal["PENDING", "IN_PROGRESS", "COMPLETED", "FAILED"]] = FieldInfo(
+        alias="workflowStatus", default=None
+    )
+    """Current workflow status"""
+
+
+class Pagination(BaseModel):
+    current_page: float = FieldInfo(alias="currentPage")
+
+    limit: float
+
+    total_items: float = FieldInfo(alias="totalItems")
+
+    total_pages: float = FieldInfo(alias="totalPages")
+
+
+class MemoryListResponse(BaseModel):
+    memories: List[Memory]
+
+    pagination: Pagination
+    """Pagination metadata"""