openaivec 0.12.5__tar.gz → 0.13.0__tar.gz

{openaivec-0.12.5 → openaivec-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openaivec
-Version: 0.12.5
+Version: 0.13.0
 Summary: Generative mutation for tabular calculation
 Project-URL: Homepage, https://microsoft.github.io/openaivec/
 Project-URL: Repository, https://github.com/microsoft/openaivec
@@ -153,13 +153,14 @@ from openai import OpenAI
 from openaivec import BatchResponses
 
 # Initialize the batch client
-client = BatchResponses(
+client = BatchResponses.of(
     client=OpenAI(),
     model_name="gpt-4.1-mini",
-    system_message="Please answer only with 'xx family' and do not output anything else."
+    system_message="Please answer only with 'xx family' and do not output anything else.",
+    batch_size=32,
 )
 
-result = client.parse(["panda", "rabbit", "koala"], batch_size=32)
+result = client.parse(["panda", "rabbit", "koala"])
 print(result)  # Expected output: ['bear family', 'rabbit family', 'koala family']
 ```
 
@@ -170,10 +171,25 @@ print(result)  # Expected output: ['bear family', 'rabbit family', 'koala family
 The easiest way to get started with your DataFrames:
 
 ```python
+import os
 import pandas as pd
 from openaivec import pandas_ext
 
-# Setup (optional - uses OPENAI_API_KEY environment variable by default)
+# Authentication Option 1: Environment variables (automatic detection)
+# For OpenAI:
+os.environ["OPENAI_API_KEY"] = "your-api-key-here"
+# Or for Azure OpenAI:
+# os.environ["AZURE_OPENAI_API_KEY"] = "your-azure-key"
+# os.environ["AZURE_OPENAI_API_ENDPOINT"] = "https://<your-resource-name>.services.ai.azure.com"
+# os.environ["AZURE_OPENAI_API_VERSION"] = "2025-04-01-preview"
+
+# Authentication Option 2: Custom client (optional)
+# from openai import OpenAI, AsyncOpenAI
+# pandas_ext.use(OpenAI())
+# For async operations:
+# pandas_ext.use_async(AsyncOpenAI())
+
+# Configure model (optional - defaults to gpt-4.1-mini)
 pandas_ext.responses_model("gpt-4.1-mini")
 
 # Create your data
@@ -230,7 +246,7 @@ extracted_results = (results
 
 **Available Task Categories:**
 
-- **Text Analysis**: `nlp.SENTIMENT_ANALYSIS`, `nlp.TRANSLATION`, `nlp.NAMED_ENTITY_RECOGNITION`, `nlp.KEYWORD_EXTRACTION`
+- **Text Analysis**: `nlp.SENTIMENT_ANALYSIS`, `nlp.MULTILINGUAL_TRANSLATION`, `nlp.NAMED_ENTITY_RECOGNITION`, `nlp.KEYWORD_EXTRACTION`
 - **Content Classification**: `customer_support.INTENT_ANALYSIS`, `customer_support.URGENCY_ANALYSIS`, `customer_support.INQUIRY_CLASSIFICATION`
 
 **Benefits of Pre-configured Tasks:**
@@ -345,7 +361,7 @@ spark.udf.register(
 )
 
 # --- Register Token Counting UDF ---
-spark.udf.register("count_tokens", count_tokens_udf("gpt-4o"))
+spark.udf.register("count_tokens", count_tokens_udf())
 
 # --- Register UDFs with Pre-configured Tasks ---
 from openaivec.task import nlp, customer_support
@@ -393,16 +409,23 @@ FROM product_reviews;
 
 Example Output (structure might vary slightly):
 
-| id   | review_text                                                                   | brand      | translation                 | sentiment | sentiment_confidence | intent           | action_required     | embedding              | token_count |
-| ---- | ----------------------------------------------------------------------------- | ---------- | --------------------------- | --------- | -------------------- | ---------------- | ------------------- | ---------------------- | ----------- |
-| 1001 | The new TechPhone X camera quality is amazing, Nexus Corp really outdid...   | Nexus Corp | {en: ..., fr: ..., ja: ...} | positive  | 0.95                 | provide_feedback | acknowledge_review  | [0.1, -0.2, ..., 0.5]  | 19          |
-| 1002 | Quantum Galaxy has great battery life but the price is too high for what...  | Quantum    | {en: ..., fr: ..., ja: ...} | mixed     | 0.78                 | provide_feedback | follow_up_pricing   | [-0.3, 0.1, ..., -0.1] | 16          |
-| 1003 | Zephyr mobile phone crashed twice today, very disappointed with this purchase | Zephyr     | {en: ..., fr: ..., ja: ...} | negative  | 0.88                 | complaint        | investigate_issue   | [0.0, 0.4, ..., 0.2]   | 12          |
+| id   | review_text                                                                   | brand      | translation                 | sentiment | sentiment_confidence | intent           | action_required    | embedding              | token_count |
+| ---- | ----------------------------------------------------------------------------- | ---------- | --------------------------- | --------- | -------------------- | ---------------- | ------------------ | ---------------------- | ----------- |
+| 1001 | The new TechPhone X camera quality is amazing, Nexus Corp really outdid...    | Nexus Corp | {en: ..., fr: ..., ja: ...} | positive  | 0.95                 | provide_feedback | acknowledge_review | [0.1, -0.2, ..., 0.5]  | 19          |
+| 1002 | Quantum Galaxy has great battery life but the price is too high for what...   | Quantum    | {en: ..., fr: ..., ja: ...} | mixed     | 0.78                 | provide_feedback | follow_up_pricing  | [-0.3, 0.1, ..., -0.1] | 16          |
+| 1003 | Zephyr mobile phone crashed twice today, very disappointed with this purchase | Zephyr     | {en: ..., fr: ..., ja: ...} | negative  | 0.88                 | complaint        | investigate_issue  | [0.0, 0.4, ..., 0.2]   | 12          |
 
 ### Spark Performance Tuning
 
 When using openaivec with Spark, proper configuration of `batch_size` and `max_concurrency` is crucial for optimal performance:
 
+**Automatic Caching** (New):
+
+- **Duplicate Detection**: All AI-powered UDFs (`responses_udf`, `task_udf`, `embeddings_udf`) automatically cache duplicate inputs within each partition
+- **Cost Reduction**: Significantly reduces API calls and costs on datasets with repeated content
+- **Transparent**: Works automatically without code changes - your existing UDFs become more efficient
+- **Partition-Level**: Each partition maintains its own cache, optimal for distributed processing patterns
+
 **`batch_size`** (default: 128):
 
 - Controls how many rows are processed together in each API request within a partition
@@ -635,16 +658,16 @@ steps:
 
      ```python
      import os
-     from pyspark.sql import SparkSession
      from openaivec.spark import responses_udf, embeddings_udf
 
-     spark = SparkSession.builder.getOrCreate()
+     # In Microsoft Fabric, spark session is automatically available
+     # spark = SparkSession.builder.getOrCreate()
      sc = spark.sparkContext
 
      # Configure Azure OpenAI authentication
      sc.environment["AZURE_OPENAI_API_KEY"] = "<your-api-key>"
-     sc.environment["AZURE_OPENAI_API_ENDPOINT"] = "https://<your-resource-name>.openai.azure.com"
-     sc.environment["AZURE_OPENAI_API_VERSION"] = "2024-10-21"
+     sc.environment["AZURE_OPENAI_API_ENDPOINT"] = "https://<your-resource-name>.services.ai.azure.com"
+     sc.environment["AZURE_OPENAI_API_VERSION"] = "2025-04-01-preview"
 
      # Register UDFs
      spark.udf.register(

{openaivec-0.12.5 → openaivec-0.13.0}/README.md

@@ -129,13 +129,14 @@ from openai import OpenAI
 from openaivec import BatchResponses
 
 # Initialize the batch client
-client = BatchResponses(
+client = BatchResponses.of(
     client=OpenAI(),
     model_name="gpt-4.1-mini",
-    system_message="Please answer only with 'xx family' and do not output anything else."
+    system_message="Please answer only with 'xx family' and do not output anything else.",
+    batch_size=32,
 )
 
-result = client.parse(["panda", "rabbit", "koala"], batch_size=32)
+result = client.parse(["panda", "rabbit", "koala"])
 print(result)  # Expected output: ['bear family', 'rabbit family', 'koala family']
 ```
 
@@ -146,10 +147,25 @@ print(result)  # Expected output: ['bear family', 'rabbit family', 'koala family
 The easiest way to get started with your DataFrames:
 
 ```python
+import os
 import pandas as pd
 from openaivec import pandas_ext
 
-# Setup (optional - uses OPENAI_API_KEY environment variable by default)
+# Authentication Option 1: Environment variables (automatic detection)
+# For OpenAI:
+os.environ["OPENAI_API_KEY"] = "your-api-key-here"
+# Or for Azure OpenAI:
+# os.environ["AZURE_OPENAI_API_KEY"] = "your-azure-key"
+# os.environ["AZURE_OPENAI_API_ENDPOINT"] = "https://<your-resource-name>.services.ai.azure.com"
+# os.environ["AZURE_OPENAI_API_VERSION"] = "2025-04-01-preview"
+
+# Authentication Option 2: Custom client (optional)
+# from openai import OpenAI, AsyncOpenAI
+# pandas_ext.use(OpenAI())
+# For async operations:
+# pandas_ext.use_async(AsyncOpenAI())
+
+# Configure model (optional - defaults to gpt-4.1-mini)
 pandas_ext.responses_model("gpt-4.1-mini")
 
 # Create your data
@@ -206,7 +222,7 @@ extracted_results = (results
 
 **Available Task Categories:**
 
-- **Text Analysis**: `nlp.SENTIMENT_ANALYSIS`, `nlp.TRANSLATION`, `nlp.NAMED_ENTITY_RECOGNITION`, `nlp.KEYWORD_EXTRACTION`
+- **Text Analysis**: `nlp.SENTIMENT_ANALYSIS`, `nlp.MULTILINGUAL_TRANSLATION`, `nlp.NAMED_ENTITY_RECOGNITION`, `nlp.KEYWORD_EXTRACTION`
 - **Content Classification**: `customer_support.INTENT_ANALYSIS`, `customer_support.URGENCY_ANALYSIS`, `customer_support.INQUIRY_CLASSIFICATION`
 
 **Benefits of Pre-configured Tasks:**
@@ -321,7 +337,7 @@ spark.udf.register(
 )
 
 # --- Register Token Counting UDF ---
-spark.udf.register("count_tokens", count_tokens_udf("gpt-4o"))
+spark.udf.register("count_tokens", count_tokens_udf())
 
 # --- Register UDFs with Pre-configured Tasks ---
 from openaivec.task import nlp, customer_support
@@ -369,16 +385,23 @@ FROM product_reviews;
 
 Example Output (structure might vary slightly):
 
-| id   | review_text                                                                   | brand      | translation                 | sentiment | sentiment_confidence | intent           | action_required     | embedding              | token_count |
-| ---- | ----------------------------------------------------------------------------- | ---------- | --------------------------- | --------- | -------------------- | ---------------- | ------------------- | ---------------------- | ----------- |
-| 1001 | The new TechPhone X camera quality is amazing, Nexus Corp really outdid...   | Nexus Corp | {en: ..., fr: ..., ja: ...} | positive  | 0.95                 | provide_feedback | acknowledge_review  | [0.1, -0.2, ..., 0.5]  | 19          |
-| 1002 | Quantum Galaxy has great battery life but the price is too high for what...  | Quantum    | {en: ..., fr: ..., ja: ...} | mixed     | 0.78                 | provide_feedback | follow_up_pricing   | [-0.3, 0.1, ..., -0.1] | 16          |
-| 1003 | Zephyr mobile phone crashed twice today, very disappointed with this purchase | Zephyr     | {en: ..., fr: ..., ja: ...} | negative  | 0.88                 | complaint        | investigate_issue   | [0.0, 0.4, ..., 0.2]   | 12          |
+| id   | review_text                                                                   | brand      | translation                 | sentiment | sentiment_confidence | intent           | action_required    | embedding              | token_count |
+| ---- | ----------------------------------------------------------------------------- | ---------- | --------------------------- | --------- | -------------------- | ---------------- | ------------------ | ---------------------- | ----------- |
+| 1001 | The new TechPhone X camera quality is amazing, Nexus Corp really outdid...    | Nexus Corp | {en: ..., fr: ..., ja: ...} | positive  | 0.95                 | provide_feedback | acknowledge_review | [0.1, -0.2, ..., 0.5]  | 19          |
+| 1002 | Quantum Galaxy has great battery life but the price is too high for what...   | Quantum    | {en: ..., fr: ..., ja: ...} | mixed     | 0.78                 | provide_feedback | follow_up_pricing  | [-0.3, 0.1, ..., -0.1] | 16          |
+| 1003 | Zephyr mobile phone crashed twice today, very disappointed with this purchase | Zephyr     | {en: ..., fr: ..., ja: ...} | negative  | 0.88                 | complaint        | investigate_issue  | [0.0, 0.4, ..., 0.2]   | 12          |
 
 ### Spark Performance Tuning
 
 When using openaivec with Spark, proper configuration of `batch_size` and `max_concurrency` is crucial for optimal performance:
 
+**Automatic Caching** (New):
+
+- **Duplicate Detection**: All AI-powered UDFs (`responses_udf`, `task_udf`, `embeddings_udf`) automatically cache duplicate inputs within each partition
+- **Cost Reduction**: Significantly reduces API calls and costs on datasets with repeated content
+- **Transparent**: Works automatically without code changes - your existing UDFs become more efficient
+- **Partition-Level**: Each partition maintains its own cache, optimal for distributed processing patterns
+
 **`batch_size`** (default: 128):
 
 - Controls how many rows are processed together in each API request within a partition
@@ -611,16 +634,16 @@ steps:
 
      ```python
      import os
-     from pyspark.sql import SparkSession
      from openaivec.spark import responses_udf, embeddings_udf
 
-     spark = SparkSession.builder.getOrCreate()
+     # In Microsoft Fabric, spark session is automatically available
+     # spark = SparkSession.builder.getOrCreate()
      sc = spark.sparkContext
 
      # Configure Azure OpenAI authentication
      sc.environment["AZURE_OPENAI_API_KEY"] = "<your-api-key>"
-     sc.environment["AZURE_OPENAI_API_ENDPOINT"] = "https://<your-resource-name>.openai.azure.com"
-     sc.environment["AZURE_OPENAI_API_VERSION"] = "2024-10-21"
+     sc.environment["AZURE_OPENAI_API_ENDPOINT"] = "https://<your-resource-name>.services.ai.azure.com"
+     sc.environment["AZURE_OPENAI_API_VERSION"] = "2025-04-01-preview"
 
      # Register UDFs
      spark.udf.register(

openaivec-0.13.0/docs/api/proxy.md

@@ -0,0 +1,102 @@
+# proxy
+
+Batching proxies for order-preserving, cached batch mapping.
+
+This module provides two helpers:
+
+- BatchingMapProxy: thread-safe synchronous batching with caching and de-duplication.
+- AsyncBatchingMapProxy: asyncio-friendly batching with optional concurrency limits.
+
+Both proxies accept the mapping function as the second argument to map(). The function must:
+
+- Accept a list of inputs and return a list of outputs in the same order.
+- Be pure relative to a single call (side effects should be idempotent or safe).
+
+## Synchronous usage (BatchingMapProxy)
+
+```python
+from typing import List
+from openaivec.proxy import BatchingMapProxy
+
+# Define your batch mapping function
+def fetch_many(keys: List[int]) -> List[str]:
+    # Example: echo values as strings
+    return [f"val:{k}" for k in keys]
+
+# Create proxy with an optional batch size hint
+proxy = BatchingMapProxy[int, str](batch_size=3)
+
+# Map items using the proxy. Duplicates are de-duplicated and order preserved.
+items = [1, 2, 2, 3, 4, 4, 5]
+outputs = proxy.map(items, fetch_many)
+assert outputs == ["val:1", "val:2", "val:2", "val:3", "val:4", "val:4", "val:5"]
+
+# Cache is reused across calls
+outputs2 = proxy.map([5, 4, 3, 2, 1], fetch_many)
+assert outputs2 == ["val:5", "val:4", "val:3", "val:2", "val:1"]
+```
+
+### Notes
+
+- If `batch_size` is None or <= 0, all unique items are processed in a single call.
+- Under concurrency, the proxy prevents duplicate work by coordinating in-flight keys.
+
+## Asynchronous usage (AsyncBatchingMapProxy)
+
+```python
+import asyncio
+from typing import List
+from openaivec.proxy import AsyncBatchingMapProxy
+
+# Define your async batch mapping function
+async def fetch_many_async(keys: List[int]) -> List[str]:
+    # Simulate I/O
+    await asyncio.sleep(0.01)
+    return [f"val:{k}" for k in keys]
+
+# Create proxy with batch size and an optional concurrency cap for map_func calls
+proxy = AsyncBatchingMapProxy[int, str](batch_size=3, max_concurrency=2)
+
+async def main():
+    items = [1, 2, 3, 4, 5]
+    out = await proxy.map(items, fetch_many_async)
+    assert out == ["val:1", "val:2", "val:3", "val:4", "val:5"]
+
+    # Overlapping requests deduplicate work and share results via the cache
+    r1 = proxy.map([1, 2, 3, 4], fetch_many_async)
+    r2 = proxy.map([3, 4, 5], fetch_many_async)
+    o1, o2 = await asyncio.gather(r1, r2)
+    assert o1 == ["val:1", "val:2", "val:3", "val:4"]
+    assert o2 == ["val:3", "val:4", "val:5"]
+
+asyncio.run(main())
+```
+
+### Notes
+
+- `max_concurrency` limits concurrent invocations of `map_func` across overlapping `map()` calls.
+- The proxy rechecks the cache immediately before each batch call to avoid redundant work.
+
+## API summary
+
+```python
+class BatchingMapProxy[S: Hashable, T]:
+    batch_size: int | None
+
+    def map(self, items: list[S], map_func: Callable[[list[S]], list[T]]) -> list[T]:
+        ...
+
+class AsyncBatchingMapProxy[S: Hashable, T]:
+    batch_size: int | None
+    max_concurrency: int
+
+    async def map(self, items: list[S], map_func: Callable[[list[S]], Awaitable[list[T]]]) -> list[T]:
+        ...
+```
+
+Implementation details:
+
+- Inputs are de-duplicated with first-occurrence order preserved.
+- Cache is filled atomically and shared across calls.
+- In-flight keys are coordinated (threading.Event / asyncio.Event) to prevent duplicated computation.
+- Errors from `map_func` propagate; in-flight keys are released to avoid deadlocks.

openaivec-0.13.0/src/openaivec/embeddings.py

@@ -0,0 +1,188 @@
+from dataclasses import dataclass, field
+from logging import Logger, getLogger
+from typing import List
+
+import numpy as np
+from numpy.typing import NDArray
+from openai import AsyncOpenAI, OpenAI, RateLimitError
+
+from .log import observe
+from .proxy import AsyncBatchingMapProxy, BatchingMapProxy
+from .util import backoff, backoff_async
+
+__all__ = [
+    "BatchEmbeddings",
+    "AsyncBatchEmbeddings",
+]
+
+_LOGGER: Logger = getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class BatchEmbeddings:
+    """Thin wrapper around the OpenAI embeddings endpoint (synchronous).
+
+    Attributes:
+        client (OpenAI): Configured OpenAI client.
+        model_name (str): Model identifier (e.g., ``"text-embedding-3-small"``).
+        cache (BatchingMapProxy[str, NDArray[np.float32]]): Batching proxy for ordered, cached mapping.
+    """
+
+    client: OpenAI
+    model_name: str
+    cache: BatchingMapProxy[str, NDArray[np.float32]] = field(default_factory=lambda: BatchingMapProxy(batch_size=128))
+
+    @classmethod
+    def of(cls, client: OpenAI, model_name: str, batch_size: int = 128) -> "BatchEmbeddings":
+        """Factory constructor.
+
+        Args:
+            client (OpenAI): OpenAI client.
+            model_name (str): Embeddings model name.
+            batch_size (int, optional): Max unique inputs per API call. Defaults to 128.
+
+        Returns:
+            BatchEmbeddings: Configured instance backed by a batching proxy.
+        """
+        return cls(client=client, model_name=model_name, cache=BatchingMapProxy(batch_size=batch_size))
+
+    @observe(_LOGGER)
+    @backoff(exception=RateLimitError, scale=15, max_retries=8)
+    def _embed_chunk(self, inputs: List[str]) -> List[NDArray[np.float32]]:
+        """Embed one minibatch of strings.
+
+        This private helper is the unit of work used by the map/parallel
+        utilities.  Exponential back‑off is applied automatically when
+        ``openai.RateLimitError`` is raised.
+
+        Args:
+            inputs (List[str]): Input strings to be embedded. Duplicates allowed.
+
+        Returns:
+            List[NDArray[np.float32]]: Embedding vectors aligned to ``inputs``.
+        """
+        responses = self.client.embeddings.create(input=inputs, model=self.model_name)
+        return [np.array(d.embedding, dtype=np.float32) for d in responses.data]
+
+    @observe(_LOGGER)
+    def create(self, inputs: List[str]) -> List[NDArray[np.float32]]:
+        """Generate embeddings for inputs using cached, ordered batching.
+
+        Args:
+            inputs (List[str]): Input strings. Duplicates allowed.
+
+        Returns:
+            List[NDArray[np.float32]]: Embedding vectors aligned to ``inputs``.
+        """
+        return self.cache.map(inputs, self._embed_chunk)
+
+
+@dataclass(frozen=True)
+class AsyncBatchEmbeddings:
+    """Thin wrapper around the OpenAI embeddings endpoint (asynchronous).
+
+    This class provides an asynchronous interface for generating embeddings using
+    OpenAI models. It manages concurrency, handles rate limits automatically,
+    and efficiently processes batches of inputs, including de-duplication.
+
+    Example:
+        ```python
+        import asyncio
+        import numpy as np
+        from openai import AsyncOpenAI
+    from openaivec import AsyncBatchEmbeddings
+
+        # Assuming openai_async_client is an initialized AsyncOpenAI client
+        openai_async_client = AsyncOpenAI() # Replace with your actual client initialization
+
+        embedder = AsyncBatchEmbeddings.of(
+            client=openai_async_client,
+            model_name="text-embedding-3-small",
+            batch_size=128,
+            max_concurrency=8,
+        )
+        texts = ["This is the first document.", "This is the second document.", "This is the first document."]
+
+        # Asynchronous call
+        async def main():
+            embeddings = await embedder.create(texts)
+            # embeddings will be a list of numpy arrays (float32)
+            # The embedding for the third text will be identical to the first
+            # due to automatic de-duplication.
+            print(f"Generated {len(embeddings)} embeddings.")
+            print(f"Shape of first embedding: {embeddings[0].shape}")
+            assert np.array_equal(embeddings[0], embeddings[2])
+
+        # Run the async function
+        asyncio.run(main())
+        ```
+
+    Attributes:
+        client (AsyncOpenAI): Configured OpenAI async client.
+        model_name (str): Embeddings model name.
+        cache (AsyncBatchingMapProxy[str, NDArray[np.float32]]): Async batching proxy.
+    """
+
+    client: AsyncOpenAI
+    model_name: str
+    cache: AsyncBatchingMapProxy[str, NDArray[np.float32]] = field(
+        default_factory=lambda: AsyncBatchingMapProxy(batch_size=128, max_concurrency=8)
+    )
+
+    @classmethod
+    def of(
+        cls,
+        client: AsyncOpenAI,
+        model_name: str,
+        batch_size: int = 128,
+        max_concurrency: int = 8,
+    ) -> "AsyncBatchEmbeddings":
+        """Factory constructor.
+
+        Args:
+            client (AsyncOpenAI): OpenAI async client.
+            model_name (str): Embeddings model name.
+            batch_size (int, optional): Max unique inputs per API call. Defaults to 128.
+            max_concurrency (int, optional): Max concurrent API calls. Defaults to 8.
+
+        Returns:
+            AsyncBatchEmbeddings: Configured instance with an async batching proxy.
+        """
+        return cls(
+            client=client,
+            model_name=model_name,
+            cache=AsyncBatchingMapProxy(batch_size=batch_size, max_concurrency=max_concurrency),
+        )
+
+    @observe(_LOGGER)
+    @backoff_async(exception=RateLimitError, scale=15, max_retries=8)
+    async def _embed_chunk(self, inputs: List[str]) -> List[NDArray[np.float32]]:
+        """Embed one minibatch of strings asynchronously.
+
+        This private helper handles the actual API call for a batch of inputs.
+        Exponential back-off is applied automatically when ``openai.RateLimitError``
+        is raised.
+
+        Args:
+            inputs (List[str]): Input strings to be embedded. Duplicates allowed.
+
+        Returns:
+            List[NDArray[np.float32]]: Embedding vectors aligned to ``inputs``.
+
+        Raises:
+            RateLimitError: Propagated if retries are exhausted.
+        """
+        responses = await self.client.embeddings.create(input=inputs, model=self.model_name)
+        return [np.array(d.embedding, dtype=np.float32) for d in responses.data]
+
+    @observe(_LOGGER)
+    async def create(self, inputs: List[str]) -> List[NDArray[np.float32]]:
+        """Generate embeddings for inputs using proxy batching (async).
+
+        Args:
+            inputs (List[str]): Input strings. Duplicates allowed.
+
+        Returns:
+            List[NDArray[np.float32]]: Embedding vectors aligned to ``inputs``.
+        """
+        return await self.cache.map(inputs, self._embed_chunk)

{openaivec-0.12.5 → openaivec-0.13.0}/src/openaivec/model.py

@@ -65,3 +65,23 @@ class ResponsesModelName:
 @dataclass(frozen=True)
 class EmbeddingsModelName:
     value: str
+
+
+@dataclass(frozen=True)
+class OpenAIAPIKey:
+    value: str
+
+
+@dataclass(frozen=True)
+class AzureOpenAIAPIKey:
+    value: str
+
+
+@dataclass(frozen=True)
+class AzureOpenAIEndpoint:
+    value: str
+
+
+@dataclass(frozen=True)
+class AzureOpenAIAPIVersion:
+    value: str