openaivec 0.12.5__py3-none-any.whl → 1.0.10__py3-none-any.whl

openaivec-1.0.10.dist-info/METADATA

@@ -0,0 +1,399 @@
+Metadata-Version: 2.4
+Name: openaivec
+Version: 1.0.10
+Summary: Generative mutation for tabular calculation
+Project-URL: Homepage, https://microsoft.github.io/openaivec/
+Project-URL: Repository, https://github.com/microsoft/openaivec
+Author-email: Hiroki Mizukami <hmizukami@microsoft.com>
+License: MIT
+License-File: LICENSE
+Keywords: llm,openai,openai-api,openai-python,pandas,pyspark
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: ipywidgets>=8.1.7
+Requires-Dist: openai>=1.74.0
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: tiktoken>=0.9.0
+Requires-Dist: tqdm>=4.67.1
+Provides-Extra: spark
+Requires-Dist: pyspark>=3.5.5; extra == 'spark'
+Description-Content-Type: text/markdown
+
+# openaivec
+
+Transform pandas and Spark workflows with AI-powered text processing—batching, caching, and guardrails included. Built for OpenAI batch pipelines so you can group prompts, cut API overhead, and keep outputs aligned with your data.
+
+[Contributor guidelines](AGENTS.md)
+
+## Quick start
+
+```bash
+pip install openaivec
+```
+
+```python
+import os
+import pandas as pd
+from openaivec import pandas_ext
+
+# Auth: choose OpenAI or Azure OpenAI
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+# Azure alternative:
+# os.environ["AZURE_OPENAI_API_KEY"] = "your-azure-key"
+# os.environ["AZURE_OPENAI_BASE_URL"] = "https://YOUR-RESOURCE-NAME.services.ai.azure.com/openai/v1/"
+# os.environ["AZURE_OPENAI_API_VERSION"] = "preview"
+
+pandas_ext.set_responses_model("gpt-5.1")  # Optional override (use deployment name for Azure)
+
+reviews = pd.Series([
+    "Great coffee and friendly staff.",
+    "Delivery was late and the package was damaged.",
+])
+
+sentiment = reviews.ai.responses(
+    "Summarize sentiment in one short sentence.",
+    reasoning={"effort": "none"},  # Mirrors OpenAI SDK for reasoning models
+)
+print(sentiment.tolist())
+# Output: ['Positive sentiment', 'Negative sentiment']
+```
+
+**Try it live:** https://microsoft.github.io/openaivec/examples/pandas/
+
+## Benchmarks
+
+Simple task benchmark from [benchmark.ipynb](https://github.com/microsoft/openaivec/blob/main/docs/examples/benchmark.ipynb) (100 numeric strings → integer literals, `Series.aio.responses`, model `gpt-5.1`):
+
+| Mode                | Settings                                        | Time (s) |
+| ------------------- | ----------------------------------------------- | -------- |
+| Serial              | `batch_size=1`, `max_concurrency=1`             | ~141     |
+| Batching            | default `batch_size`, `max_concurrency=1`       | ~15      |
+| Concurrent batching | default `batch_size`, default `max_concurrency` | ~6       |
+
+Batching alone removes most HTTP overhead, and letting batching overlap with concurrency cuts total runtime to a few seconds while still yielding one output per input.
+
+<img alt="image" src="https://github.com/user-attachments/assets/8ace9bcd-bcae-4023-a37e-13082cd645e5" />
+
+## Contents
+
+- [Why openaivec?](#why-openaivec)
+- [Core Workflows](#core-workflows)
+- [Using with Apache Spark UDFs](#using-with-apache-spark-udfs)
+- [Building Prompts](#building-prompts)
+- [Using with Microsoft Fabric](#using-with-microsoft-fabric)
+- [Contributing](#contributing)
+- [Additional Resources](#additional-resources)
+- [Community](#community)
+
+## Why openaivec?
+
+- Drop-in `.ai` and `.aio` accessors keep pandas analysts in familiar tooling.
+- OpenAI batch-optimized: `BatchingMapProxy`/`AsyncBatchingMapProxy` coalesce requests, dedupe prompts, and keep column order stable.
+- Smart batching (`BatchingMapProxy`/`AsyncBatchingMapProxy`) dedupes prompts, preserves order, and releases waiters on failure.
+- Reasoning support mirrors the OpenAI SDK; structured outputs accept Pydantic `response_format`.
+- Built-in caches and retries remove boilerplate; helpers reuse caches across pandas, Spark, and async flows.
+- Spark UDFs and Microsoft Fabric guides move notebooks into production-scale ETL.
+- Prompt tooling (`FewShotPromptBuilder`, `improve`) and the task library ship curated prompts with validated outputs.
+
+# Overview
+
+Vectorized OpenAI batch processing so you handle many inputs per call instead of one-by-one. Batching proxies dedupe inputs, enforce ordered outputs, and unblock waiters even on upstream errors. Cache helpers (`responses_with_cache`, Spark UDF builders) plug into the same layer so expensive prompts are reused across pandas, Spark, and async flows. Reasoning models honor SDK semantics. Requires Python 3.10+.
+
+## Core Workflows
+
+### Direct API usage
+
+For maximum control over batch processing:
+
+```python
+import os
+from openai import OpenAI
+from openaivec import BatchResponses
+
+# Initialize the batch client
+client = BatchResponses.of(
+    client=OpenAI(),
+    model_name="gpt-5.1",
+    system_message="Please answer only with 'xx family' and do not output anything else.",
+    # batch_size defaults to None (automatic optimization)
+)
+
+result = client.parse(
+    ["panda", "rabbit", "koala"],
+    reasoning={"effort": "none"},
+)
+print(result)  # Expected output: ['bear family', 'rabbit family', 'koala family']
+```
+
+📓 **[Complete tutorial →](https://microsoft.github.io/openaivec/examples/pandas/)**
+
+### pandas integration (recommended)
+
+The easiest way to get started with your DataFrames:
+
+```python
+import os
+import pandas as pd
+from openaivec import pandas_ext
+
+# Authentication Option 1: Environment variables (automatic detection)
+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_BASE_URL"] = "https://YOUR-RESOURCE-NAME.services.ai.azure.com/openai/v1/"
+# os.environ["AZURE_OPENAI_API_VERSION"] = "preview"
+
+# Authentication Option 2: Custom client (optional)
+# from openai import OpenAI, AsyncOpenAI
+# pandas_ext.set_client(OpenAI())
+# pandas_ext.set_async_client(AsyncOpenAI())
+
+# Configure model (optional - defaults to gpt-5.1; use deployment name for Azure)
+pandas_ext.set_responses_model("gpt-5.1")
+
+# Create your data
+df = pd.DataFrame({"name": ["panda", "rabbit", "koala"]})
+
+# Add AI-powered columns
+result = df.assign(
+    family=lambda df: df.name.ai.responses(
+        "What animal family? Answer with 'X family'",
+        reasoning={"effort": "none"},
+    ),
+    habitat=lambda df: df.name.ai.responses(
+        "Primary habitat in one word",
+        reasoning={"effort": "none"},
+    ),
+    fun_fact=lambda df: df.name.ai.responses(
+        "One interesting fact in 10 words or less",
+        reasoning={"effort": "none"},
+    ),
+)
+```
+
+| name   | family           | habitat | fun_fact                   |
+| ------ | ---------------- | ------- | -------------------------- |
+| panda  | bear family      | forest  | Eats bamboo 14 hours daily |
+| rabbit | rabbit family    | meadow  | Can see nearly 360 degrees |
+| koala  | marsupial family | tree    | Sleeps 22 hours per day    |
+
+📓 **[Interactive pandas examples →](https://microsoft.github.io/openaivec/examples/pandas/)**
+
+### Using with reasoning models
+
+Reasoning models (o1-preview, o1-mini, o3-mini, etc.) work without special flags. `reasoning` mirrors the OpenAI SDK.
+
+```python
+pandas_ext.set_responses_model("o1-mini")  # Set your reasoning model
+
+result = df.assign(
+    analysis=lambda df: df.text.ai.responses(
+        "Analyze this text step by step",
+        reasoning={"effort": "none"}  # Optional: mirrors the OpenAI SDK argument
+    )
+)
+```
+
+You can omit `reasoning` to use the model defaults or tune it per request with the same shape (`dict` with effort) as the OpenAI SDK.
+
+### Using pre-configured tasks
+
+For common text processing operations, openaivec provides ready-to-use tasks that eliminate the need to write custom prompts:
+
+```python
+from openaivec.task import nlp, customer_support
+
+text_df = pd.DataFrame({
+    "text": [
+        "Great product, fast delivery!",
+        "Need help with billing issue",
+        "How do I reset my password?"
+    ]
+})
+
+results = text_df.assign(
+    sentiment=lambda df: df.text.ai.task(
+        nlp.SENTIMENT_ANALYSIS,
+        reasoning={"effort": "none"},
+    ),
+    intent=lambda df: df.text.ai.task(
+        customer_support.INTENT_ANALYSIS,
+        reasoning={"effort": "none"},
+    ),
+)
+
+# Extract structured results into separate columns
+extracted_results = results.ai.extract("sentiment")
+```
+
+**Task categories:** 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`).
+
+### Asynchronous processing with `.aio`
+
+High-throughput workloads use the `.aio` accessor for async versions of all operations:
+
+```python
+import asyncio
+import pandas as pd
+from openaivec import pandas_ext
+
+pandas_ext.set_responses_model("gpt-5.1")
+
+df = pd.DataFrame({"text": [
+    "This product is amazing!",
+    "Terrible customer service",
+    "Good value for money",
+    "Not what I expected"
+] * 250})  # 1000 rows for demonstration
+
+async def process_data():
+    return await df["text"].aio.responses(
+        "Analyze sentiment and classify as positive/negative/neutral",
+        reasoning={"effort": "none"},  # Required for gpt-5.1
+        max_concurrency=12    # Allow up to 12 concurrent requests
+    )
+
+sentiments = asyncio.run(process_data())
+```
+
+**Performance benefits:** Parallel processing with automatic batching/deduplication, built-in rate limiting and error handling, and memory-efficient streaming for large datasets.
+
+## Using with Apache Spark UDFs
+
+Scale to enterprise datasets with distributed processing.
+
+📓 **[Spark tutorial →](https://microsoft.github.io/openaivec/examples/spark/)**
+
+First, obtain a Spark session and configure authentication:
+
+```python
+from pyspark.sql import SparkSession
+from openaivec.spark import setup, setup_azure
+
+spark = SparkSession.builder.getOrCreate()
+
+# Option 1: Using OpenAI
+setup(
+    spark,
+    api_key="your-openai-api-key",
+    responses_model_name="gpt-5.1",  # Optional: set default model
+    embeddings_model_name="text-embedding-3-small"  # Optional: set default model
+)
+
+# Option 2: Using Azure OpenAI
+# setup_azure(
+#     spark,
+#     api_key="your-azure-openai-api-key",
+#     base_url="https://YOUR-RESOURCE-NAME.services.ai.azure.com/openai/v1/",
+#     api_version="preview",
+#     responses_model_name="my-gpt4-deployment",  # Optional: set default deployment
+#     embeddings_model_name="my-embedding-deployment"  # Optional: set default deployment
+# )
+```
+
+Create and register UDFs using the provided helpers:
+
+```python
+from openaivec.spark import responses_udf, task_udf, embeddings_udf, count_tokens_udf, similarity_udf, parse_udf
+from pydantic import BaseModel
+
+spark.udf.register(
+    "extract_brand",
+    responses_udf(
+        instructions="Extract the brand name from the product. Return only the brand name.",
+        reasoning={"effort": "none"},  # Recommended with gpt-5.1
+    )
+)
+
+class Translation(BaseModel):
+    en: str
+    fr: str
+    ja: str
+
+spark.udf.register(
+    "translate_struct",
+    responses_udf(
+        instructions="Translate the text to English, French, and Japanese.",
+        response_format=Translation,
+        reasoning={"effort": "none"},  # Recommended with gpt-5.1
+    )
+)
+
+spark.udf.register("embed_text", embeddings_udf())
+spark.udf.register("count_tokens", count_tokens_udf())
+spark.udf.register("compute_similarity", similarity_udf())
+```
+
+### Spark performance tips
+
+- Duplicate detection automatically caches repeated inputs per partition for UDFs.
+- `batch_size=None` auto-optimizes; set 32–128 for fixed sizes if needed.
+- `max_concurrency` is per executor; total concurrency = executors × max_concurrency. Start with 4–12.
+- Monitor rate limits and adjust concurrency to your OpenAI tier.
+
+## Building Prompts
+
+Few-shot prompts improve LLM quality. `FewShotPromptBuilder` structures purpose, cautions, and examples; `improve()` iterates with OpenAI to remove contradictions.
+
+```python
+from openaivec import FewShotPromptBuilder
+
+prompt = (
+    FewShotPromptBuilder()
+    .purpose("Return the smallest category that includes the given word")
+    .caution("Never use proper nouns as categories")
+    .example("Apple", "Fruit")
+    .example("Car", "Vehicle")
+    .improve(max_iter=1)  # optional
+    .build()
+)
+```
+
+📓 **[Advanced prompting techniques →](https://microsoft.github.io/openaivec/examples/prompt/)**
+
+## Using with Microsoft Fabric
+
+[Microsoft Fabric](https://www.microsoft.com/en-us/microsoft-fabric/) is a unified, cloud-based analytics platform. Add `openaivec` from PyPI in your Fabric environment, select it in your notebook, and use `openaivec.spark` like standard Spark.
+
+## Contributing
+
+We welcome contributions! Please:
+
+1. Fork and branch from `main`.
+2. Add or update tests when you change code.
+3. Run formatting and tests before opening a PR.
+
+Install dev deps:
+
+```bash
+uv sync --all-extras --dev
+```
+
+Lint and format:
+
+```bash
+uv run ruff check . --fix
+```
+
+Quick test pass:
+
+```bash
+uv run pytest -m "not slow and not requires_api"
+```
+
+## Additional Resources
+
+📓 **[Customer feedback analysis →](https://microsoft.github.io/openaivec/examples/customer_analysis/)** - Sentiment analysis & prioritization  
+📓 **[Survey data transformation →](https://microsoft.github.io/openaivec/examples/survey_transformation/)** - Unstructured to structured data  
+📓 **[Asynchronous processing examples →](https://microsoft.github.io/openaivec/examples/aio/)** - High-performance async workflows  
+📓 **[Auto-generate FAQs from documents →](https://microsoft.github.io/openaivec/examples/generate_faq/)** - Create FAQs using AI  
+📓 **[All examples →](https://microsoft.github.io/openaivec/examples/pandas/)** - Complete collection of tutorials and use cases
+
+## Community
+
+Join our Discord community for support and announcements: https://discord.gg/hXCS9J6Qek

openaivec-1.0.10.dist-info/RECORD

@@ -0,0 +1,39 @@
+openaivec/__init__.py,sha256=0RsOGIt4TMgPdjppWiz89W1gb1X4qM-4nWqFFi-eK8w,555
+openaivec/_di.py,sha256=Cl1ZoNBlQsJL1bpzoMDl08uT9pZFVSlqOdLbS3_MwPE,11462
+openaivec/_embeddings.py,sha256=2JWFUZdHR1dvPdWPT4nVSZo0_TAz4gr8oLR3EhhtUyE,8200
+openaivec/_log.py,sha256=LHNs6AbJzM4weaRARZFroigxR6D148d7WSIMLk1IhbU,1439
+openaivec/_model.py,sha256=ICu9T2puXBMIkTOZdO7XStHMdSSHe4LmLVovsNfXb64,2744
+openaivec/_prompt.py,sha256=_fPATuWKaAdFD48Kuu0UQorlChA9mNZCDJx88bu_BuY,20626
+openaivec/_provider.py,sha256=h-h2LwnaTDg-WquhD908upOSbMaMxV5OxoWWxfCdBTs,7952
+openaivec/_responses.py,sha256=82P_iO3uB0IBL0BZY51ncR02lGxoVzLDjCybTvliMR8,20661
+openaivec/_serialize.py,sha256=u2Om94Sc_QgJkTlW2BAGw8wd6gYDhc6IRqvS-qevFSs,8399
+openaivec/_util.py,sha256=XfueAycVCQvgRLS7wF7e306b53lebORvZOBzbQjy4vE,6438
+openaivec/pandas_ext.py,sha256=_y48qlG-npZsCCJJL1yev-yEU1YBZT83EiVl-lH0__o,87305
+openaivec/spark.py,sha256=XosDAcbzhnaIGyHBJ-p_ZBVJALroOXOFTjWWNRpSG3o,35022
+openaivec/_cache/__init__.py,sha256=IYUH5GKsJXuCX-k3XtT259rEz49EZm9KW2TIOTGW4uQ,314
+openaivec/_cache/optimize.py,sha256=3nS8VehbS7iGC1tPDDQh-iAgyKHbVYmMbCRBWM77U_U,3827
+openaivec/_cache/proxy.py,sha256=aVjH_hmJIIso6SetV_-Ct3VaOSG-n9Dpil7TttnbYkE,30556
+openaivec/_schema/__init__.py,sha256=XUj3Jv6ZVDjyYzSmH6Q5lmDj-hBMfUg_eBNeZACXR6Q,368
+openaivec/_schema/infer.py,sha256=VyvORgmpkcPa8pITClOJYjNzF4VzgSWe_n-9kFJVUjE,15644
+openaivec/_schema/spec.py,sha256=7ZaC59w2Edemnao57XeZVO4qmSOA-Kus6TchZC3Dd5o,14821
+openaivec/task/__init__.py,sha256=E82gfwhLOn1S8rgNZZAci3-H7bDXdGFM-cl1fpeN7_o,6154
+openaivec/task/customer_support/__init__.py,sha256=KWfGyXPdZyfGdRH17x7hPpJJ1N2EP9PPhZx0fvBAwSI,884
+openaivec/task/customer_support/customer_sentiment.py,sha256=ixSIPKZkqAtp4h2SaCDItNT4WNWSbuWVv4CQEY2insg,7375
+openaivec/task/customer_support/inquiry_classification.py,sha256=O94-4csaqJmbpSOYX0Dvay6N3hbAbLhrWDRS-BG5qTM,9401
+openaivec/task/customer_support/inquiry_summary.py,sha256=MqdrVsS5TmcArtU_G_C-ETse93-LxjsRBXTiizha6xU,6695
+openaivec/task/customer_support/intent_analysis.py,sha256=fFvjfebe3luvshr9E63TSoKf5zgFeU3l2lSLBLOVOGM,7311
+openaivec/task/customer_support/response_suggestion.py,sha256=Ewi0C_ytzKOZdQMRzkuXTuT8epFfeCekmh_c7F7vkqE,8105
+openaivec/task/customer_support/urgency_analysis.py,sha256=tqQ4JvZpT4DN_A3Wn7DkLl1iwnRgV83yIICipQB-AqI,11330
+openaivec/task/nlp/__init__.py,sha256=QoQ0egEK9IEh5hdrE07rZ_KCmC0gy_2FPrWJYRWiipY,512
+openaivec/task/nlp/dependency_parsing.py,sha256=ijDXFRNC9h9Tn7kaDS9ecijdLkanoP-WIqA-QrtUFwY,2803
+openaivec/task/nlp/keyword_extraction.py,sha256=TGcW-wXJwnUNT2p_tGyapyDCgzCPKGYLc2iNYq9dN8o,2790
+openaivec/task/nlp/morphological_analysis.py,sha256=7mfpLPKnE5WWFKRwhpfh1PuvT-LcbRH7jiuUCLBcpYU,2379
+openaivec/task/nlp/named_entity_recognition.py,sha256=iGvN8Z5iYynyOWgsBMxy_ztoivYKRsw-sBR8_SuwUcM,3015
+openaivec/task/nlp/sentiment_analysis.py,sha256=P1AFazqmlE9Dy0OShNOXcY8X5rvsGg7X6CRysdqXORI,3063
+openaivec/task/nlp/translation.py,sha256=IgTy0PQZVF_Q6qis60STim7Vd7rYPVTfTfwP_U1kAKk,6603
+openaivec/task/table/__init__.py,sha256=kJz15WDJXjyC7UIHKBvlTRhCf347PCDMH5T5fONV2sU,83
+openaivec/task/table/fillna.py,sha256=nMlXvlUvyWgM9DxJDeRX3M37jxlqg0MgRet1Ds3ni5Y,6571
+openaivec-1.0.10.dist-info/METADATA,sha256=xJPQaqzzlN7rkL519vee4l8ZQRQfVwl9UxkXyzXGToM,14195
+openaivec-1.0.10.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+openaivec-1.0.10.dist-info/licenses/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
+openaivec-1.0.10.dist-info/RECORD,,

{openaivec-0.12.5.dist-info → openaivec-1.0.10.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

openaivec/embeddings.py

@@ -1,172 +0,0 @@
-import asyncio
-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 .util import backoff, backoff_async, map, map_async
-
-__all__ = [
-    "BatchEmbeddings",
-    "AsyncBatchEmbeddings",
-]
-
-_LOGGER: Logger = getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class BatchEmbeddings:
-    """Thin wrapper around the OpenAI /embeddings endpoint.
-
-    Attributes:
-        client: An already‑configured ``openai.OpenAI`` client.
-        model_name: The model identifier, e.g. ``"text-embedding-3-small"``.
-    """
-
-    client: OpenAI
-    model_name: str
-
-    @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 sentences.
-
-        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 are allowed; the
-                implementation may decide to de‑duplicate internally.
-
-        Returns:
-            List of embedding vectors with the same ordering as *sentences*.
-        """
-        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], batch_size: int) -> List[NDArray[np.float32]]:
-        """See ``VectorizedEmbeddings.create`` for contract details.
-
-        The call is internally delegated to either ``map_unique_minibatch`` or
-        its parallel counterpart depending on *is_parallel*.
-
-        Args:
-            inputs (List[str]): A list of input strings. Duplicates are allowed; the
-                implementation may decide to de‑duplicate internally.
-            batch_size (int): Maximum number of sentences to be sent to the underlying
-                model in one request.
-
-        Returns:
-            A list of ``np.ndarray`` objects (dtype ``float32``) where each entry
-                is the embedding of the corresponding sentence in *sentences*.
-
-        Raises:
-            openai.RateLimitError: Propagated if retries are exhausted.
-        """
-        return map(inputs, self._embed_chunk, batch_size)
-
-
-@dataclass(frozen=True)
-class AsyncBatchEmbeddings:
-    """Thin wrapper around the OpenAI /embeddings endpoint using async operations.
-
-    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.aio.embeddings import AsyncBatchEmbeddings
-
-        # Assuming openai_async_client is an initialized AsyncOpenAI client
-        openai_async_client = AsyncOpenAI() # Replace with your actual client initialization
-
-        embedder = AsyncBatchEmbeddings(
-            client=openai_async_client,
-            model_name="text-embedding-3-small",
-            max_concurrency=8  # Limit concurrent requests
-        )
-        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, batch_size=128)
-            # 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: An already‑configured ``openai.AsyncOpenAI`` client.
-        model_name: The model identifier, e.g. ``"text-embedding-3-small"``.
-        max_concurrency: Maximum number of concurrent requests to the OpenAI API.
-    """
-
-    client: AsyncOpenAI
-    model_name: str
-    max_concurrency: int = 8  # Default concurrency limit
-    _semaphore: asyncio.Semaphore = field(init=False, repr=False)
-
-    def __post_init__(self):
-        # Initialize the semaphore after the object is created
-        # Use object.__setattr__ because the dataclass is frozen
-        object.__setattr__(self, "_semaphore", asyncio.Semaphore(self.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 sentences asynchronously, respecting concurrency limits.
-
-        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 are allowed.
-
-        Returns:
-            List of embedding vectors (``np.ndarray`` with dtype ``float32``)
-            in the same order as *inputs*.
-
-        Raises:
-            openai.RateLimitError: Propagated if retries are exhausted.
-        """
-        # Acquire semaphore before making the API call
-        async with self._semaphore:
-            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], batch_size: int) -> List[NDArray[np.float32]]:
-        """Asynchronous public API: generate embeddings for a list of inputs.
-
-        Uses ``openaivec.util.map_async`` to efficiently handle batching and de-duplication.
-
-        Args:
-            inputs (List[str]): A list of input strings. Duplicates are handled efficiently.
-            batch_size (int): Maximum number of unique inputs per API call.
-
-        Returns:
-            A list of ``np.ndarray`` objects (dtype ``float32``) where each entry
-            is the embedding of the corresponding string in *inputs*.
-
-        Raises:
-            openai.RateLimitError: Propagated if retries are exhausted during API calls.
-        """
-
-        return await map_async(inputs, self._embed_chunk, batch_size)

openaivec/model.py

@@ -1,67 +0,0 @@
-from dataclasses import dataclass
-from typing import Type, TypeVar
-
-from pydantic import BaseModel
-
-ResponseFormat = TypeVar("ResponseFormat", bound=BaseModel | str)
-
-
-@dataclass(frozen=True)
-class PreparedTask:
-    """A data class representing a complete task configuration for OpenAI API calls.
-
-    This class encapsulates all the necessary parameters for executing a task,
-    including the instructions to be sent to the model, the expected response
-    format using Pydantic models, and sampling parameters for controlling
-    the model's output behavior.
-
-    Attributes:
-        instructions (str): The prompt or instructions to send to the OpenAI model.
-            This should contain clear, specific directions for the task.
-        response_format (Type[ResponseFormat]): A Pydantic model class or str type that defines the expected
-            structure of the response. Can be either a BaseModel subclass or str.
-        temperature (float): Controls randomness in the model's output.
-            Range: 0.0 to 1.0. Lower values make output more deterministic.
-            Defaults to 0.0.
-        top_p (float): Controls diversity via nucleus sampling. Only tokens
-            comprising the top_p probability mass are considered.
-            Range: 0.0 to 1.0. Defaults to 1.0.
-
-    Example:
-        Creating a custom task:
-
-        ```python
-        from pydantic import BaseModel
-
-        class TranslationResponse(BaseModel):
-            translated_text: str
-            source_language: str
-            target_language: str
-
-        custom_task = PreparedTask(
-            instructions="Translate the following text to French:",
-            response_format=TranslationResponse,
-            temperature=0.1,
-            top_p=0.9
-        )
-        ```
-
-    Note:
-        This class is frozen (immutable) to ensure task configurations
-        cannot be accidentally modified after creation.
-    """
-
-    instructions: str
-    response_format: Type[ResponseFormat]
-    temperature: float = 0.0
-    top_p: float = 1.0
-
-
-@dataclass(frozen=True)
-class ResponsesModelName:
-    value: str
-
-
-@dataclass(frozen=True)
-class EmbeddingsModelName:
-    value: str