supermemory 3.0.0a19__py3-none-any.whl → 3.0.0a20__py3-none-any.whl

supermemory/types/connection_get_response.py → supermemory_new/types/connection_get_by_id_response.py

@@ -6,10 +6,10 @@ from pydantic import Field as FieldInfo
 
 from .._models import BaseModel
 
-__all__ = ["ConnectionGetResponse"]
+__all__ = ["ConnectionGetByIDResponse"]
 
 
-class ConnectionGetResponse(BaseModel):
+class ConnectionGetByIDResponse(BaseModel):
     id: str
 
     created_at: float = FieldInfo(alias="createdAt")

supermemory_new/types/connection_get_by_tags_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 import List
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["ConnectionGetByTagsParams"]
+
+
+class ConnectionGetByTagsParams(TypedDict, total=False):
+    container_tags: Required[Annotated[List[str], PropertyInfo(alias="containerTags")]]
+    """Comma-separated list of container tags to filter connection by"""

supermemory_new/types/connection_get_by_tags_response.py

@@ -0,0 +1,25 @@
+# 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__ = ["ConnectionGetByTagsResponse"]
+
+
+class ConnectionGetByTagsResponse(BaseModel):
+    id: str
+
+    created_at: float = FieldInfo(alias="createdAt")
+
+    provider: str
+
+    document_limit: Optional[float] = FieldInfo(alias="documentLimit", default=None)
+
+    email: Optional[str] = None
+
+    expires_at: Optional[float] = FieldInfo(alias="expiresAt", default=None)
+
+    metadata: Optional[Dict[str, object]] = None

supermemory_new/types/connection_import_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 import List
+from typing_extensions import Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["ConnectionImportParams"]
+
+
+class ConnectionImportParams(TypedDict, total=False):
+    container_tags: Annotated[List[str], PropertyInfo(alias="containerTags")]
+    """Optional comma-separated list of container tags to filter connections by"""

supermemory_new/types/connection_list_documents_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 import List
+from typing_extensions import Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["ConnectionListDocumentsParams"]
+
+
+class ConnectionListDocumentsParams(TypedDict, total=False):
+    container_tags: Annotated[List[str], PropertyInfo(alias="containerTags")]
+    """Optional comma-separated list of container tags to filter documents by"""

supermemory_new/types/connection_list_documents_response.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["ConnectionListDocumentsResponse", "ConnectionListDocumentsResponseItem"]
+
+
+class ConnectionListDocumentsResponseItem(BaseModel):
+    id: str
+
+    created_at: str = FieldInfo(alias="createdAt")
+
+    status: str
+
+    summary: Optional[str] = None
+
+    title: Optional[str] = None
+
+    type: str
+
+    updated_at: str = FieldInfo(alias="updatedAt")
+
+
+ConnectionListDocumentsResponse: TypeAlias = List[ConnectionListDocumentsResponseItem]

supermemory_new/types/connection_list_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 import List
+from typing_extensions import Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["ConnectionListParams"]
+
+
+class ConnectionListParams(TypedDict, total=False):
+    container_tags: Annotated[List[str], PropertyInfo(alias="containerTags")]
+    """Optional comma-separated list of container tags to filter documents by"""

supermemory_new/types/connection_list_response.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from typing_extensions import TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["ConnectionListResponse", "ConnectionListResponseItem"]
+
+
+class ConnectionListResponseItem(BaseModel):
+    id: str
+
+    created_at: float = FieldInfo(alias="createdAt")
+
+    provider: str
+
+    document_limit: Optional[float] = FieldInfo(alias="documentLimit", default=None)
+
+    email: Optional[str] = None
+
+    expires_at: Optional[float] = FieldInfo(alias="expiresAt", default=None)
+
+    metadata: Optional[Dict[str, object]] = None
+
+
+ConnectionListResponse: TypeAlias = List[ConnectionListResponseItem]

supermemory_new/types/memory_list_params.py

@@ -0,0 +1,34 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from typing_extensions import Literal, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["MemoryListParams"]
+
+
+class MemoryListParams(TypedDict, total=False):
+    container_tags: Annotated[List[str], PropertyInfo(alias="containerTags")]
+    """Optional tags this memory should be containerized by.
+
+    This can be an ID for your user, a project ID, or any other identifier you wish
+    to use to group memories.
+    """
+
+    filters: str
+    """Optional filters to apply to the search"""
+
+    limit: Union[str, float]
+    """Number of items per page"""
+
+    order: Literal["asc", "desc"]
+    """Sort order"""
+
+    page: Union[str, float]
+    """Page number to fetch"""
+
+    sort: Literal["createdAt", "updatedAt"]
+    """Field to sort by"""

supermemory_new/types/memory_list_response.py

@@ -0,0 +1,91 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, 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."""
+
+    connection_id: Optional[str] = FieldInfo(alias="connectionId", default=None)
+    """Optional ID of connection the memory was created from.
+
+    This is useful for identifying the source of the memory.
+    """
+
+    created_at: datetime = FieldInfo(alias="createdAt")
+    """Creation timestamp"""
+
+    custom_id: Optional[str] = FieldInfo(alias="customId", default=None)
+    """Optional custom ID of the memory.
+
+    This could be an ID from your database that will uniquely identify this memory.
+    """
+
+    metadata: Union[str, float, bool, Dict[str, object], List[object], None] = None
+    """Optional metadata for the memory.
+
+    This is used to store additional information about the memory. You can use this
+    to store any additional information you need about the memory. Metadata can be
+    filtered through. Keys must be strings and are case sensitive. Values can be
+    strings, numbers, or booleans. You cannot nest objects.
+    """
+
+    status: Literal["unknown", "queued", "extracting", "chunking", "embedding", "indexing", "done", "failed"]
+    """Status of the memory"""
+
+    summary: Optional[str] = None
+    """Summary of the memory content"""
+
+    title: Optional[str] = None
+    """Title of the memory"""
+
+    type: Literal[
+        "text",
+        "pdf",
+        "tweet",
+        "google_doc",
+        "google_slide",
+        "google_sheet",
+        "image",
+        "video",
+        "notion_doc",
+        "webpage",
+        "onedrive",
+    ]
+    """Type of the memory"""
+
+    updated_at: datetime = FieldInfo(alias="updatedAt")
+    """Last update timestamp"""
+
+    container_tags: Optional[List[str]] = FieldInfo(alias="containerTags", default=None)
+    """Optional tags this memory should be containerized by.
+
+    This can be an ID for your user, a project ID, or any other identifier you wish
+    to use to group memories.
+    """
+
+
+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"""

supermemory_new/types/search_execute_params.py

@@ -0,0 +1,93 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Union, Iterable
+from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["SearchExecuteParams", "Filters", "FiltersUnionMember0"]
+
+
+class SearchExecuteParams(TypedDict, total=False):
+    q: Required[str]
+    """Search query string"""
+
+    categories_filter: Annotated[
+        List[Literal["technology", "science", "business", "health"]], PropertyInfo(alias="categoriesFilter")
+    ]
+    """Optional category filters"""
+
+    chunk_threshold: Annotated[float, PropertyInfo(alias="chunkThreshold")]
+    """Threshold / sensitivity for chunk selection.
+
+    0 is least sensitive (returns most chunks, more results), 1 is most sensitive
+    (returns lesser chunks, accurate results)
+    """
+
+    container_tags: Annotated[List[str], PropertyInfo(alias="containerTags")]
+    """Optional tags this search should be containerized by.
+
+    This can be an ID for your user, a project ID, or any other identifier you wish
+    to use to filter memories.
+    """
+
+    doc_id: Annotated[str, PropertyInfo(alias="docId")]
+    """Optional document ID to search within.
+
+    You can use this to find chunks in a very large document.
+    """
+
+    document_threshold: Annotated[float, PropertyInfo(alias="documentThreshold")]
+    """Threshold / sensitivity for document selection.
+
+    0 is least sensitive (returns most documents, more results), 1 is most sensitive
+    (returns lesser documents, accurate results)
+    """
+
+    filters: Filters
+    """Optional filters to apply to the search"""
+
+    include_full_docs: Annotated[bool, PropertyInfo(alias="includeFullDocs")]
+    """If true, include full document in the response.
+
+    This is helpful if you want a chatbot to know the full context of the document.
+    """
+
+    include_summary: Annotated[bool, PropertyInfo(alias="includeSummary")]
+    """If true, include document summary in the response.
+
+    This is helpful if you want a chatbot to know the full context of the document.
+    """
+
+    limit: int
+    """Maximum number of results to return"""
+
+    only_matching_chunks: Annotated[bool, PropertyInfo(alias="onlyMatchingChunks")]
+    """If true, only return matching chunks without context.
+
+    Normally, we send the previous and next chunk to provide more context for LLMs.
+    If you only want the matching chunk, set this to true.
+    """
+
+    rerank: bool
+    """If true, rerank the results based on the query.
+
+    This is helpful if you want to ensure the most relevant results are returned.
+    """
+
+    rewrite_query: Annotated[bool, PropertyInfo(alias="rewriteQuery")]
+    """If true, rewrites the query to make it easier to find documents.
+
+    This increases the latency by about 400ms
+    """
+
+
+class FiltersUnionMember0(TypedDict, total=False):
+    and_: Annotated[Iterable[object], PropertyInfo(alias="AND")]
+
+    or_: Annotated[Iterable[object], PropertyInfo(alias="OR")]
+
+
+Filters: TypeAlias = Union[FiltersUnionMember0, Dict[str, object]]

supermemory_new/types/search_execute_response.py

@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from datetime import datetime
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["SearchExecuteResponse", "Result", "ResultChunk"]
+
+
+class ResultChunk(BaseModel):
+    content: str
+    """Content of the matching chunk"""
+
+    is_relevant: bool = FieldInfo(alias="isRelevant")
+    """Whether this chunk is relevant to the query"""
+
+    score: float
+    """Similarity score for this chunk"""
+
+
+class Result(BaseModel):
+    chunks: List[ResultChunk]
+    """Matching content chunks from the document"""
+
+    created_at: datetime = FieldInfo(alias="createdAt")
+    """Document creation date"""
+
+    document_id: str = FieldInfo(alias="documentId")
+    """ID of the matching document"""
+
+    metadata: Optional[Dict[str, object]] = None
+    """Document metadata"""
+
+    score: float
+    """Relevance score of the match"""
+
+    title: Optional[str] = None
+    """Document title"""
+
+    updated_at: datetime = FieldInfo(alias="updatedAt")
+    """Document last update date"""
+
+    summary: Optional[str] = None
+    """Document summary"""
+
+
+class SearchExecuteResponse(BaseModel):
+    results: List[Result]
+
+    timing: float
+
+    total: float

supermemory/_version.py

@@ -1,4 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-__title__ = "supermemory"
-__version__ = "3.0.0-alpha.19"  # x-release-please-version