lambdadb 0.7.4.dev0__tar.gz → 0.7.5.dev0__tar.gz

{lambdadb-0.7.4.dev0 → lambdadb-0.7.5.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambdadb
-Version: 0.7.4.dev0
+Version: 0.7.5.dev0
 Summary: The Official LambdaDB Python SDK.
 License-File: LICENSE
 Author: Functional Systems, Inc.
@@ -159,6 +159,40 @@ with LambdaDB(
     coll.docs.upsert(docs=[{"id": "1", "text": "hello"}])
 ```
 
+### Create a collection with managed embeddings
+
+Managed embedding vector fields set `managedEmbedding=True` and put provider/model/source
+settings under `embedding`. Do not set top-level `dimensions` or `similarity` on managed
+embedding vector fields. For unmanaged vector fields, keep using top-level `dimensions`.
+
+```python
+from lambdadb import LambdaDB, models
+
+with LambdaDB(
+    project_api_key="<YOUR_PROJECT_API_KEY>",
+    base_url="https://api.lambdadb.ai",
+    project_name="playground",
+) as client:
+    client.collections.create(
+        collection_name="articles",
+        index_configs={
+            "body": {
+                "type": models.TypeText.TEXT,
+                "analyzers": [models.Analyzer.ENGLISH],
+            },
+            "bodyEmbedding": {
+                "type": models.TypeVector.VECTOR,
+                "managedEmbedding": True,
+                "embedding": {
+                    "provider": models.Provider.OPENAI,
+                    "model": "text-embedding-3-small",
+                    "sourceField": "body",
+                },
+            },
+        },
+    )
+```
+
 ### List all collections (sync / async)
 
 ```python
@@ -568,3 +602,4 @@ looking for the latest version.
 
 While we value open-source contributions to this SDK, this library is generated programmatically. Any manual changes added to internal files will be overwritten on the next generation. 
 We look forward to hearing your feedback. Feel free to open a PR or an issue with a proof of concept and we'll do our best to include it in a future release.
+

{lambdadb-0.7.4.dev0 → lambdadb-0.7.5.dev0}/README.md

@@ -138,6 +138,40 @@ with LambdaDB(
     coll.docs.upsert(docs=[{"id": "1", "text": "hello"}])
 ```
 
+### Create a collection with managed embeddings
+
+Managed embedding vector fields set `managedEmbedding=True` and put provider/model/source
+settings under `embedding`. Do not set top-level `dimensions` or `similarity` on managed
+embedding vector fields. For unmanaged vector fields, keep using top-level `dimensions`.
+
+```python
+from lambdadb import LambdaDB, models
+
+with LambdaDB(
+    project_api_key="<YOUR_PROJECT_API_KEY>",
+    base_url="https://api.lambdadb.ai",
+    project_name="playground",
+) as client:
+    client.collections.create(
+        collection_name="articles",
+        index_configs={
+            "body": {
+                "type": models.TypeText.TEXT,
+                "analyzers": [models.Analyzer.ENGLISH],
+            },
+            "bodyEmbedding": {
+                "type": models.TypeVector.VECTOR,
+                "managedEmbedding": True,
+                "embedding": {
+                    "provider": models.Provider.OPENAI,
+                    "model": "text-embedding-3-small",
+                    "sourceField": "body",
+                },
+            },
+        },
+    )
+```
+
 ### List all collections (sync / async)
 
 ```python
@@ -546,4 +580,4 @@ looking for the latest version.
 ## Contributions
 
 While we value open-source contributions to this SDK, this library is generated programmatically. Any manual changes added to internal files will be overwritten on the next generation. 
-We look forward to hearing your feedback. Feel free to open a PR or an issue with a proof of concept and we'll do our best to include it in a future release.
+We look forward to hearing your feedback. Feel free to open a PR or an issue with a proof of concept and we'll do our best to include it in a future release.

{lambdadb-0.7.4.dev0 → lambdadb-0.7.5.dev0}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "lambdadb"
-version = "0.7.4.dev0"
+version = "0.7.5.dev0"
 description = "The Official LambdaDB Python SDK."
 authors = [{ name = "Functional Systems, Inc." },]
 readme = "README.md"
@@ -57,4 +57,3 @@ ignore_missing_imports = true
 venvPath = "."
 venv = ".venv"
 extraPaths = ["src"]
-

{lambdadb-0.7.4.dev0 → lambdadb-0.7.5.dev0}/src/lambdadb/models/__init__.py

@@ -63,6 +63,8 @@ if TYPE_CHECKING:
     )
     from .indexconfigs_union import (
         Analyzer,
+        EmbeddingConfig,
+        EmbeddingConfigTypedDict,
         IndexConfigs,
         IndexConfigsObject,
         IndexConfigsObjectTypedDict,
@@ -73,6 +75,7 @@ if TYPE_CHECKING:
         IndexConfigsUnionTypedDict,
         IndexConfigsVector,
         IndexConfigsVectorTypedDict,
+        Provider,
         Similarity,
         Type,
         TypeObject,
@@ -146,6 +149,8 @@ __all__ = [
     "DeleteDocsRequestBody",
     "DeleteDocsRequestBodyTypedDict",
     "DeleteDocsRequestTypedDict",
+    "EmbeddingConfig",
+    "EmbeddingConfigTypedDict",
     "FetchDocsDoc",
     "FetchDocsDocTypedDict",
     "FetchDocsRequest",
@@ -194,6 +199,7 @@ __all__ = [
     "PartitionConfigTypedDict",
     "PartitionFilter",
     "PartitionFilterTypedDict",
+    "Provider",
     "QueryCollectionDoc",
     "QueryCollectionDocTypedDict",
     "QueryCollectionRequest",
@@ -268,6 +274,8 @@ _dynamic_imports: dict[str, str] = {
     "GetCollectionResponse": ".getcollectionop",
     "GetCollectionResponseTypedDict": ".getcollectionop",
     "Analyzer": ".indexconfigs_union",
+    "EmbeddingConfig": ".indexconfigs_union",
+    "EmbeddingConfigTypedDict": ".indexconfigs_union",
     "IndexConfigs": ".indexconfigs_union",
     "IndexConfigsObject": ".indexconfigs_union",
     "IndexConfigsObjectTypedDict": ".indexconfigs_union",
@@ -278,6 +286,7 @@ _dynamic_imports: dict[str, str] = {
     "IndexConfigsUnionTypedDict": ".indexconfigs_union",
     "IndexConfigsVector": ".indexconfigs_union",
     "IndexConfigsVectorTypedDict": ".indexconfigs_union",
+    "Provider": ".indexconfigs_union",
     "Similarity": ".indexconfigs_union",
     "Type": ".indexconfigs_union",
     "TypeObject": ".indexconfigs_union",

lambdadb-0.7.5.dev0/src/lambdadb/models/indexconfigs_union.py

@@ -0,0 +1,275 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+from lambdadb.types import BaseModel, UNSET_SENTINEL
+from lambdadb.utils import get_discriminator
+import pydantic
+from pydantic import Discriminator, Tag, model_serializer, model_validator
+from typing import Any, Dict, List, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+MIN_VECTOR_DIMENSIONS = 1
+MAX_VECTOR_DIMENSIONS = 4096
+
+
+class TypeObject(str, Enum):
+    OBJECT = "object"
+
+
+class IndexConfigsObjectTypedDict(TypedDict):
+    type: TypeObject
+    object_index_configs: Dict[str, Any]
+
+
+class IndexConfigsObject(BaseModel):
+    type: TypeObject
+
+    object_index_configs: Annotated[
+        Dict[str, Any], pydantic.Field(alias="objectIndexConfigs")
+    ]
+
+
+class Type(str, Enum):
+    KEYWORD = "keyword"
+    LONG = "long"
+    DOUBLE = "double"
+    DATETIME = "datetime"
+    BOOLEAN = "boolean"
+    SPARSE_VECTOR = "sparseVector"
+
+
+class IndexConfigsTypedDict(TypedDict):
+    r"""Types that do not need additional parameters."""
+
+    type: Type
+
+
+class IndexConfigs(BaseModel):
+    r"""Types that do not need additional parameters."""
+
+    type: Type
+
+
+class TypeVector(str, Enum):
+    VECTOR = "vector"
+
+
+class Provider(str, Enum):
+    r"""Embedding provider."""
+
+    OPENAI = "openai"
+
+
+class Similarity(str, Enum):
+    r"""Vector similarity metric."""
+
+    COSINE = "cosine"
+    EUCLIDEAN = "euclidean"
+    DOT_PRODUCT = "dot_product"
+    MAX_INNER_PRODUCT = "max_inner_product"
+
+
+class EmbeddingConfigTypedDict(TypedDict):
+    r"""Managed embedding configuration for vector fields."""
+
+    provider: Provider
+    r"""Embedding provider."""
+    model: str
+    r"""Embedding model name. See /guides/collections/managed-embeddings for the current supported providers and models."""
+    source_field: str
+    r"""Source text field name used to generate embeddings."""
+    dimensions: NotRequired[int]
+    r"""Resolved embedding dimensions. Optional in requests and resolved in stored collection metadata."""
+    similarity: NotRequired[Similarity]
+    r"""Resolved vector similarity metric. Optional in requests and resolved in stored collection metadata."""
+
+
+class EmbeddingConfig(BaseModel):
+    r"""Managed embedding configuration for vector fields."""
+
+    provider: Provider
+    r"""Embedding provider."""
+
+    model: str
+    r"""Embedding model name. See /guides/collections/managed-embeddings for the current supported providers and models."""
+
+    source_field: Annotated[str, pydantic.Field(alias="sourceField")]
+    r"""Source text field name used to generate embeddings."""
+
+    dimensions: Optional[int] = None
+    r"""Resolved embedding dimensions. Optional in requests and resolved in stored collection metadata."""
+
+    similarity: Optional[Similarity] = Similarity.COSINE
+    r"""Resolved vector similarity metric. Optional in requests and resolved in stored collection metadata."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["dimensions", "similarity"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = self._get_serialized_value(serialized, n, f.alias)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class IndexConfigsVectorTypedDict(TypedDict):
+    type: TypeVector
+    managed_embedding: NotRequired[bool]
+    r"""Set to true for managed embedding vector fields, or false/omit for unmanaged vector fields."""
+    dimensions: NotRequired[int]
+    r"""Vector dimensions for unmanaged vector fields."""
+    similarity: NotRequired[Similarity]
+    r"""Vector similarity metric for unmanaged vector fields."""
+    embedding: NotRequired[EmbeddingConfigTypedDict]
+    r"""Managed embedding configuration for vector fields."""
+
+
+class IndexConfigsVector(BaseModel):
+    type: TypeVector
+
+    managed_embedding: Annotated[
+        Optional[bool], pydantic.Field(alias="managedEmbedding")
+    ] = None
+    r"""Set to true for managed embedding vector fields, or false/omit for unmanaged vector fields."""
+
+    dimensions: Optional[int] = None
+    r"""Vector dimensions for unmanaged vector fields."""
+
+    similarity: Optional[Similarity] = Similarity.COSINE
+    r"""Vector similarity metric for unmanaged vector fields."""
+
+    embedding: Optional[EmbeddingConfig] = None
+    r"""Managed embedding configuration for vector fields."""
+
+    @model_validator(mode="after")
+    def validate_vector_type(self):
+        if self.managed_embedding is None and self.embedding is not None:
+            raise ValueError(
+                "managedEmbedding=true is required when embedding config is provided"
+            )
+
+        if self.managed_embedding is True:
+            if "dimensions" in self.model_fields_set and self.dimensions is not None:
+                raise ValueError(
+                    "Top-level dimensions are not allowed for managed embedding field"
+                )
+            if "similarity" in self.model_fields_set and self.similarity is not None:
+                raise ValueError(
+                    "Top-level similarity is not allowed for managed embedding field"
+                )
+            if self.embedding is None:
+                raise ValueError("embedding is required when managedEmbedding=true")
+
+            return self
+
+        if self.embedding is not None:
+            raise ValueError("embedding is not allowed when managedEmbedding=false")
+
+        if self.dimensions is None:
+            raise ValueError("Dimensions is required field")
+        if (
+            self.dimensions > MAX_VECTOR_DIMENSIONS
+            or self.dimensions < MIN_VECTOR_DIMENSIONS
+        ):
+            raise ValueError(
+                f"Dimensions must be between {MIN_VECTOR_DIMENSIONS} and {MAX_VECTOR_DIMENSIONS}"
+            )
+
+        return self
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["managedEmbedding", "dimensions", "similarity", "embedding"]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = self._get_serialized_value(serialized, n, f.alias)
+
+            if self.managed_embedding is True and k == "similarity":
+                continue
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class TypeText(str, Enum):
+    TEXT = "text"
+
+
+class Analyzer(str, Enum):
+    STANDARD = "standard"
+    KOREAN = "korean"
+    JAPANESE = "japanese"
+    ENGLISH = "english"
+
+
+class IndexConfigsTextTypedDict(TypedDict):
+    type: TypeText
+    analyzers: NotRequired[List[Analyzer]]
+    r"""Analyzers."""
+
+
+class IndexConfigsText(BaseModel):
+    type: TypeText
+
+    analyzers: Optional[List[Analyzer]] = None
+    r"""Analyzers."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["analyzers"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = self._get_serialized_value(serialized, n, f.alias)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+IndexConfigsUnionTypedDict = TypeAliasType(
+    "IndexConfigsUnionTypedDict",
+    Union[
+        IndexConfigsTypedDict,
+        IndexConfigsTextTypedDict,
+        IndexConfigsObjectTypedDict,
+        IndexConfigsVectorTypedDict,
+    ],
+)
+
+
+IndexConfigsUnion = Annotated[
+    Union[
+        Annotated[IndexConfigsText, Tag("text")],
+        Annotated[IndexConfigsVector, Tag("vector")],
+        Annotated[IndexConfigs, Tag("keyword")],
+        Annotated[IndexConfigs, Tag("long")],
+        Annotated[IndexConfigs, Tag("double")],
+        Annotated[IndexConfigs, Tag("datetime")],
+        Annotated[IndexConfigs, Tag("boolean")],
+        Annotated[IndexConfigs, Tag("sparseVector")],
+        Annotated[IndexConfigsObject, Tag("object")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]

{lambdadb-0.7.4.dev0 → lambdadb-0.7.5.dev0}/src/lambdadb/version.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 TITLE: str = "lambdadb"
-SDK_VERSION: str = "0.7.4.dev0"
+SDK_VERSION: str = "0.7.5.dev0"
 OPENAPI_DOC_VERSION: str = "1.1.1"
 GEN_VERSION: str = "2.798.0"
 

lambdadb-0.7.4.dev0/src/lambdadb/models/indexconfigs_union.py

@@ -1,162 +0,0 @@
-"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
-
-from __future__ import annotations
-from enum import Enum
-from lambdadb.types import BaseModel, UNSET_SENTINEL
-from lambdadb.utils import get_discriminator
-import pydantic
-from pydantic import Discriminator, Tag, model_serializer
-from typing import Any, Dict, List, Optional, Union
-from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
-
-
-class TypeObject(str, Enum):
-    OBJECT = "object"
-
-
-class IndexConfigsObjectTypedDict(TypedDict):
-    type: TypeObject
-    object_index_configs: Dict[str, Any]
-
-
-class IndexConfigsObject(BaseModel):
-    type: TypeObject
-
-    object_index_configs: Annotated[
-        Dict[str, Any], pydantic.Field(alias="objectIndexConfigs")
-    ]
-
-
-class Type(str, Enum):
-    KEYWORD = "keyword"
-    LONG = "long"
-    DOUBLE = "double"
-    DATETIME = "datetime"
-    BOOLEAN = "boolean"
-    SPARSE_VECTOR = "sparseVector"
-
-
-class IndexConfigsTypedDict(TypedDict):
-    r"""Types that do not need additional parameters."""
-
-    type: Type
-
-
-class IndexConfigs(BaseModel):
-    r"""Types that do not need additional parameters."""
-
-    type: Type
-
-
-class TypeVector(str, Enum):
-    VECTOR = "vector"
-
-
-class Similarity(str, Enum):
-    r"""Vector similarity metric."""
-
-    COSINE = "cosine"
-    EUCLIDEAN = "euclidean"
-    DOT_PRODUCT = "dot_product"
-    MAX_INNER_PRODUCT = "max_inner_product"
-
-
-class IndexConfigsVectorTypedDict(TypedDict):
-    type: TypeVector
-    dimensions: int
-    r"""Vector dimensions."""
-    similarity: NotRequired[Similarity]
-    r"""Vector similarity metric."""
-
-
-class IndexConfigsVector(BaseModel):
-    type: TypeVector
-
-    dimensions: int
-    r"""Vector dimensions."""
-
-    similarity: Optional[Similarity] = Similarity.COSINE
-    r"""Vector similarity metric."""
-
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        optional_fields = set(["similarity"])
-        serialized = handler(self)
-        m = {}
-
-        for n, f in type(self).model_fields.items():
-            k = f.alias or n
-            val = self._get_serialized_value(serialized, n, f.alias)
-
-            if val != UNSET_SENTINEL:
-                if val is not None or k not in optional_fields:
-                    m[k] = val
-
-        return m
-
-
-class TypeText(str, Enum):
-    TEXT = "text"
-
-
-class Analyzer(str, Enum):
-    STANDARD = "standard"
-    KOREAN = "korean"
-    JAPANESE = "japanese"
-    ENGLISH = "english"
-
-
-class IndexConfigsTextTypedDict(TypedDict):
-    type: TypeText
-    analyzers: NotRequired[List[Analyzer]]
-    r"""Analyzers."""
-
-
-class IndexConfigsText(BaseModel):
-    type: TypeText
-
-    analyzers: Optional[List[Analyzer]] = None
-    r"""Analyzers."""
-
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        optional_fields = set(["analyzers"])
-        serialized = handler(self)
-        m = {}
-
-        for n, f in type(self).model_fields.items():
-            k = f.alias or n
-            val = self._get_serialized_value(serialized, n, f.alias)
-
-            if val != UNSET_SENTINEL:
-                if val is not None or k not in optional_fields:
-                    m[k] = val
-
-        return m
-
-
-IndexConfigsUnionTypedDict = TypeAliasType(
-    "IndexConfigsUnionTypedDict",
-    Union[
-        IndexConfigsTypedDict,
-        IndexConfigsTextTypedDict,
-        IndexConfigsObjectTypedDict,
-        IndexConfigsVectorTypedDict,
-    ],
-)
-
-
-IndexConfigsUnion = Annotated[
-    Union[
-        Annotated[IndexConfigsText, Tag("text")],
-        Annotated[IndexConfigsVector, Tag("vector")],
-        Annotated[IndexConfigs, Tag("keyword")],
-        Annotated[IndexConfigs, Tag("long")],
-        Annotated[IndexConfigs, Tag("double")],
-        Annotated[IndexConfigs, Tag("datetime")],
-        Annotated[IndexConfigs, Tag("boolean")],
-        Annotated[IndexConfigs, Tag("sparseVector")],
-        Annotated[IndexConfigsObject, Tag("object")],
-    ],
-    Discriminator(lambda m: get_discriminator(m, "type", "type")),
-]