openaivec 0.13.3__tar.gz → 0.13.5__tar.gz

openaivec-0.13.5/.github/copilot-instructions.md

@@ -0,0 +1,199 @@
+# Copilot instructions for openaivec
+
+This repository-wide guide tells GitHub Copilot how to propose code that fits our architecture, APIs, style, tests, and docs. Prefer these rules when completing or generating code.
+
+## Project overview
+
+- Goal: Provide a vectorized (batched) interface to OpenAI/Azure OpenAI so pandas/Spark can process large text corpora with high throughput.
+- Public API exports (`src/openaivec/__init__.py`):
+  - Responses: `BatchResponses`, `AsyncBatchResponses`
+  - Embeddings: `BatchEmbeddings`, `AsyncBatchEmbeddings`
+- First-class pandas extensions (`.ai` / `.aio`) and Spark UDF builders
+- Azure OpenAI is supported with the same APIs (use deployment name as the “model” for Azure)
+
+## Architecture and roles
+
+- `src/openaivec/proxy.py`
+  - Core batching, deduplication, order preservation, and caching
+  - `BatchingMapProxy[S, T]` (sync) / `AsyncBatchingMapProxy[S, T]` (async)
+  - The map_func contract is strict: return a list of the same length and order as the inputs
+  - Progress bars only in notebook environments via `tqdm.auto`, gated by `show_progress=True`
+- `src/openaivec/responses.py`
+  - Batched wrapper over OpenAI Responses JSON-mode API
+  - `BatchResponses` / `AsyncBatchResponses` use the proxy internally
+  - Retries via `backoff`/`backoff_async` for transient errors (RateLimit, 5xx)
+  - Reasoning models (o1/o3 family) must use `temperature=None`; helpful guidance on errors
+- `src/openaivec/embeddings.py`
+  - Batched embeddings (sync/async)
+- `src/openaivec/pandas_ext.py`
+  - `Series.ai` / `Series.aio` entry points for responses/embeddings
+  - Uses DI container (`provider.CONTAINER`) to get client and model names
+  - Supports batch size, progress, and cache sharing (`*_with_cache`)
+- `src/openaivec/spark.py`
+  - UDF builders: `responses_udf` / `task_udf` / `embeddings_udf` / `count_tokens_udf` / `split_to_chunks_udf`
+  - Per-partition duplicate caching to reduce API calls
+  - Pydantic → Spark StructType schema conversion
+- `src/openaivec/provider.py`
+  - DI container and automatic OpenAI/Azure OpenAI client provisioning
+  - Warns if Azure base URL isn’t v1 format
+- `src/openaivec/util.py`
+  - `backoff` / `backoff_async` and `TextChunker`
+- Additional modules from CLAUDE.md
+  - `src/openaivec/di.py`: lightweight DI container
+  - `src/openaivec/log.py`: logging/observe helpers
+  - `src/openaivec/prompt.py`: few-shot prompt building
+  - `src/openaivec/serialize.py`: Pydantic schema (de)serialization
+  - `src/openaivec/task/`: pre-built, structured task library
+
+## Dev commands (uv)
+
+```bash
+# Install all dependencies (dev + extras)
+uv sync --all-extras --dev
+
+# Install in editable mode
+uv pip install -e .
+
+# Lint and format
+uv run ruff check . --fix && uv run ruff format .
+
+# Run tests
+uv run pytest
+
+# Build/serve docs
+uv run mkdocs serve
+```
+
+## Coding standards (Ruff/types/style)
+
+- Python ≥ 3.10
+- Lint/format via Ruff (line-length=120, target=py310)
+- Imports: absolute only (enforced by TID252), except `__init__.py` may re-export relatively
+- Type hints required using modern syntax (`str | None` over `Optional[str]`)
+- Public APIs should document return values and exceptions (Google-style docstrings preferred)
+- Favor `@dataclass` for simple data contracts; separate mutable state cleanly
+- Don’t swallow errors broadly; raise `ValueError` etc. on contract violations
+
+## API contracts and critical rules
+
+- Proxy (BatchingMapProxy / AsyncBatchingMapProxy)
+  - map_func must return a list with the same length and order as inputs; on mismatch, release events and raise ValueError
+  - Inputs are de-duplicated while preserving first-occurrence order; outputs are restored to the original order
+  - Progress is only shown in notebooks when `show_progress=True`
+  - Async version enforces `max_concurrency` via `asyncio.Semaphore`
+- Responses
+  - Use OpenAI Responses JSON mode (`responses.parse`)
+  - For reasoning models (o1/o3 families), you MUST set `temperature=None`; helpful error messaging is built-in
+  - Strongly prefer structured outputs with Pydantic models
+  - Retries with exponential backoff for RateLimit/5xx
+- Embeddings
+  - Return NumPy float32 arrays
+- pandas extensions
+  - `.ai.responses` / `.ai.embeddings` strictly preserve Series index and length
+  - `.aio` provides async variants; tune with `max_concurrency` and `batch_size`
+  - `*_with_cache` variants let callers share external caches across ops
+- Spark UDFs
+  - Cache duplicates within each partition to minimize API cost
+  - Convert Pydantic models to Spark schemas; treat Enum/Literal as strings
+  - Reasoning models require `temperature=None`
+  - Provide token counting and text chunking helpers
+- Provider/DI and Azure
+  - Auto-detect OpenAI vs Azure OpenAI from env vars
+  - Azure requires v1 base URL (warn otherwise) and uses deployment name as the “model”
+
+## Preferred patterns (Do) and Avoid (Don’t)
+
+Do
+
+- Batch through the Proxy rather than per-item loops
+- Attach `backoff`/`backoff_async` to external API calls (RateLimit, 5xx)
+- Preserve index/order/schema for pandas/Spark APIs
+- Clarify Azure specifics (“deployment name” vs “model name”); respect `_check_azure_v1_api_url`
+- When changing public APIs, update `__all__` and docs in `docs/`
+
+Don’t
+
+- Break the Proxy contract (same-length, ordered result)
+- Fire one API request per item—always batch via the Proxy
+- Show progress outside notebook contexts or ignore `show_progress`
+- Use relative imports (except `__init__.py` re-exports)
+- Hit real external APIs in unit tests (prefer mocks/stubs)
+
+## Performance guidance
+
+- Typical batch size ranges: Responses 32–128, Embeddings 64–256 (defaults are 128 in code)
+- Async `max_concurrency` commonly 4–12 per process/partition; scale with rate limits in mind
+- Partition-level caching (Spark) and cross-op cache sharing (pandas `*_with_cache`) greatly reduce costs
+
+## Testing strategy (pytest)
+
+- Tests live in `tests/`; cover both sync and async where applicable
+- Prefer mocks/stubs for external API calls; keep data small and deterministic
+- Focus areas:
+  - Order/length preservation
+  - Deduplication and cache reuse
+  - Event release on exceptions (deadlock prevention)
+  - `max_concurrency` is not exceeded
+  - Reasoning model guidance (`temperature=None`)
+- Use `asyncio.run` in async tests (mirrors existing tests)
+- Optional integration tests can run with valid API keys; keep unit tests independent of network
+
+## Documentation (MkDocs)
+
+- For new developer-facing APIs, update `docs/api/` and consider a short example under `docs/examples/`
+- Keep pandas/Spark examples concise to minimize learning curve
+- Update `mkdocs.yml` navigation when adding modules or examples
+
+## PR checklist (pre-merge)
+
+- [ ] Ruff check/format passes (line-length 120, absolute imports)
+- [ ] Public API contracts (order/length/types) are satisfied
+- [ ] Large-scale processing is batched via the Proxy
+- [ ] Reasoning models use `temperature=None` where applicable
+- [ ] Tests added/updated without calling live external APIs
+- [ ] Docs updated if needed (`docs/` and/or examples)
+
+## Common snippets (what to suggest)
+
+- New batched API wrapper (sync)
+
+  ```python
+  @observe(_LOGGER)
+  @backoff(exceptions=[RateLimitError, InternalServerError], scale=1, max_retries=12)
+  def _unit_of_work(self, xs: list[str]) -> list[TOut]:
+      resp = self.client.api(xs)  # real API call
+      return convert(resp)        # same length/order as xs
+
+  def create(self, inputs: list[str]) -> list[TOut]:
+      return self.cache.map(inputs, self._unit_of_work)
+  ```
+
+- Reasoning model temperature
+  ```python
+  # o1/o3 and similar reasoning models must use None
+  temperature=None
+  ```
+- pandas `.ai` with shared cache
+
+  ```python
+  from openaivec.proxy import BatchingMapProxy
+
+  shared = BatchingMapProxy[str, str](batch_size=64)
+  df["text"].ai.responses_with_cache("instructions", cache=shared)
+  ```
+
+- Spark UDF (structured output)
+
+  ```python
+  from pydantic import BaseModel
+  from openaivec.spark import responses_udf
+
+  class R(BaseModel):
+      value: str
+
+  udf = responses_udf("do something", response_format=R, batch_size=64, max_concurrency=8)
+  ```
+
+---
+
+By following this guide, Copilot suggestions will match the repository’s design, performance goals, and testing standards. When in doubt, read the implementations in `proxy.py`, `responses.py`, `pandas_ext.py`, and `spark.py`, and the tests under `tests/`.

{openaivec-0.13.3 → openaivec-0.13.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openaivec
-Version: 0.13.3
+Version: 0.13.5
 Summary: Generative mutation for tabular calculation
 Project-URL: Homepage, https://microsoft.github.io/openaivec/
 Project-URL: Repository, https://github.com/microsoft/openaivec

{openaivec-0.13.3 → openaivec-0.13.5}/mkdocs.yml

@@ -61,6 +61,7 @@ nav:
       - Async Workflows: examples/aio.ipynb
       - Prompt Engineering: examples/prompt.ipynb
       - FAQ Generation: examples/generate_faq.ipynb
+      - Token Count and Processing Time: examples/batch_size.ipynb
   - API Reference:
       - di: api/di.md
       - pandas_ext: api/pandas_ext.md

openaivec-0.13.5/src/openaivec/optimize.py

@@ -0,0 +1,108 @@
+import threading
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import List
+
+
+@dataclass(frozen=True)
+class PerformanceMetric:
+    duration: float
+    batch_size: int
+    executed_at: datetime
+    exception: BaseException | None = None
+
+
+@dataclass
+class BatchSizeSuggester:
+    current_batch_size: int = 10
+    min_batch_size: int = 10
+    min_duration: float = 30.0
+    max_duration: float = 60.0
+    step_ratio: float = 0.1
+    sample_size: int = 10
+    _history: List[PerformanceMetric] = field(default_factory=list)
+    _lock: threading.RLock = field(default_factory=threading.RLock, repr=False)
+    _batch_size_changed_at: datetime | None = field(default=None, init=False)
+
+    def __post_init__(self) -> None:
+        if self.min_batch_size <= 0:
+            raise ValueError("min_batch_size must be > 0")
+        if self.current_batch_size < self.min_batch_size:
+            raise ValueError("current_batch_size must be >= min_batch_size")
+        if self.sample_size <= 0:
+            raise ValueError("sample_size must be > 0")
+        if self.step_ratio <= 0:
+            raise ValueError("step_ratio must be > 0")
+        if self.min_duration <= 0 or self.max_duration <= 0:
+            raise ValueError("min_duration and max_duration must be > 0")
+        if self.min_duration >= self.max_duration:
+            raise ValueError("min_duration must be < max_duration")
+
+    @contextmanager
+    def record(self, batch_size: int):
+        start_time = time.perf_counter()
+        executed_at = datetime.now(timezone.utc)
+        caught_exception: BaseException | None = None
+        try:
+            yield
+        except BaseException as e:
+            caught_exception = e
+            raise
+        finally:
+            duration = time.perf_counter() - start_time
+            with self._lock:
+                self._history.append(
+                    PerformanceMetric(
+                        duration=duration,
+                        batch_size=batch_size,
+                        executed_at=executed_at,
+                        exception=caught_exception,
+                    )
+                )
+
+    @property
+    def samples(self) -> List[PerformanceMetric]:
+        with self._lock:
+            selected: List[PerformanceMetric] = []
+            for metric in reversed(self._history):
+                if metric.exception is not None:
+                    continue
+                if self._batch_size_changed_at and metric.executed_at < self._batch_size_changed_at:
+                    continue
+                selected.append(metric)
+                if len(selected) >= self.sample_size:
+                    break
+            return list(reversed(selected))
+
+    def clear_history(self):
+        with self._lock:
+            self._history.clear()
+
+    def suggest_batch_size(self) -> int:
+        selected = self.samples
+
+        if len(selected) < self.sample_size:
+            with self._lock:
+                return self.current_batch_size
+
+        average_duration = sum(m.duration for m in selected) / len(selected)
+
+        with self._lock:
+            current_size = self.current_batch_size
+
+            if average_duration < self.min_duration:
+                new_batch_size = int(current_size * (1 + self.step_ratio))
+            elif average_duration > self.max_duration:
+                new_batch_size = int(current_size * (1 - self.step_ratio))
+            else:
+                new_batch_size = current_size
+
+            new_batch_size = max(new_batch_size, self.min_batch_size)
+
+            if new_batch_size != self.current_batch_size:
+                self._batch_size_changed_at = datetime.now(timezone.utc)
+                self.current_batch_size = new_batch_size
+
+            return self.current_batch_size

{openaivec-0.13.3 → openaivec-0.13.5}/src/openaivec/proxy.py

@@ -4,6 +4,8 @@ from collections.abc import Hashable
 from dataclasses import dataclass, field
 from typing import Awaitable, Callable, Dict, Generic, List, Optional, TypeVar
 
+from openaivec.optimize import BatchSizeSuggester
+
 S = TypeVar("S", bound=Hashable)
 T = TypeVar("T")
 
@@ -22,6 +24,7 @@ class ProxyBase(Generic[S, T]):
 
     batch_size: Optional[int] = None  # subclasses may override via dataclass
     show_progress: bool = False  # Enable progress bar display
+    suggester: BatchSizeSuggester = None  # Batch size optimization, initialized by subclasses
 
     def _is_notebook_environment(self) -> bool:
         """Check if running in a Jupyter notebook environment.
@@ -125,7 +128,7 @@ class ProxyBase(Generic[S, T]):
             progress_bar.close()
 
     @staticmethod
-    def __unique_in_order(seq: List[S]) -> List[S]:
+    def _unique_in_order(seq: List[S]) -> List[S]:
         """Return unique items preserving their first-occurrence order.
 
         Args:
@@ -143,11 +146,11 @@ class ProxyBase(Generic[S, T]):
                 out.append(x)
         return out
 
-    def __normalized_batch_size(self, total: int) -> int:
+    def _normalized_batch_size(self, total: int) -> int:
         """Compute the effective batch size used for processing.
 
-        If ``batch_size`` is not set or non-positive, the entire ``total`` is
-        processed in a single call.
+        If ``batch_size`` is None, use the suggester to determine optimal batch size.
+        If ``batch_size`` is non-positive, process the entire ``total`` in a single call.
 
         Args:
             total (int): Number of items intended to be processed.
@@ -155,7 +158,15 @@ class ProxyBase(Generic[S, T]):
         Returns:
             int: The positive batch size to use.
         """
-        return self.batch_size if (self.batch_size and self.batch_size > 0) else total
+        if self.batch_size and self.batch_size > 0:
+            return self.batch_size
+        elif self.batch_size is None:
+            # Use suggester to determine optimal batch size
+            suggested = self.suggester.suggest_batch_size()
+            return min(suggested, total)  # Don't exceed total items
+        else:
+            # batch_size is 0 or negative, process all at once
+            return total
 
 
 @dataclass
@@ -180,19 +191,13 @@ class BatchingMapProxy(ProxyBase[S, T], Generic[S, T]):
     # Number of items to process per call to map_func. If None or <= 0, process all at once.
     batch_size: Optional[int] = None
     show_progress: bool = False
+    suggester: BatchSizeSuggester = field(default_factory=BatchSizeSuggester, repr=False)
+
+    # internals
     __cache: Dict[S, T] = field(default_factory=dict)
-    # Thread-safety primitives (not part of public API)
     __lock: threading.RLock = field(default_factory=threading.RLock, repr=False)
     __inflight: Dict[S, threading.Event] = field(default_factory=dict, repr=False)
 
-    # ---- private helpers -------------------------------------------------
-    # expose base helpers under subclass private names for compatibility
-    __unique_in_order = staticmethod(ProxyBase._ProxyBase__unique_in_order)
-    __normalized_batch_size = ProxyBase._ProxyBase__normalized_batch_size
-    _create_progress_bar = ProxyBase._create_progress_bar
-    _update_progress_bar = ProxyBase._update_progress_bar
-    _close_progress_bar = ProxyBase._close_progress_bar
-
     def __all_cached(self, items: List[S]) -> bool:
         """Check whether all items are present in the cache.
 
@@ -320,16 +325,17 @@ class BatchingMapProxy(ProxyBase[S, T], Generic[S, T]):
         """
         if not owned:
             return
-        batch_size = self.__normalized_batch_size(len(owned))
+        # Setup progress bar
+        progress_bar = self._create_progress_bar(len(owned))
 
         # Accumulate uncached items to maximize batch size utilization
         pending_to_call: List[S] = []
 
-        # Setup progress bar
-        progress_bar = self._create_progress_bar(len(owned))
-
-        for i in range(0, len(owned), batch_size):
-            batch = owned[i : i + batch_size]
+        i = 0
+        while i < len(owned):
+            # Get dynamic batch size for each iteration
+            current_batch_size = self._normalized_batch_size(len(owned))
+            batch = owned[i : i + current_batch_size]
             # Double-check cache right before processing
             with self.__lock:
                 uncached_in_batch = [x for x in batch if x not in self.__cache]
@@ -337,14 +343,16 @@ class BatchingMapProxy(ProxyBase[S, T], Generic[S, T]):
             pending_to_call.extend(uncached_in_batch)
 
             # Process accumulated items when we reach batch_size or at the end
-            is_last_batch = i + batch_size >= len(owned)
-            if len(pending_to_call) >= batch_size or (is_last_batch and pending_to_call):
+            is_last_batch = i + current_batch_size >= len(owned)
+            if len(pending_to_call) >= current_batch_size or (is_last_batch and pending_to_call):
                 # Take up to batch_size items to process
-                to_call = pending_to_call[:batch_size]
-                pending_to_call = pending_to_call[batch_size:]
+                to_call = pending_to_call[:current_batch_size]
+                pending_to_call = pending_to_call[current_batch_size:]
 
                 try:
-                    results = map_func(to_call)
+                    # Always measure execution time using suggester
+                    with self.suggester.record(len(to_call)):
+                        results = map_func(to_call)
                 except Exception:
                     self.__finalize_failure(to_call)
                     raise
@@ -353,13 +361,19 @@ class BatchingMapProxy(ProxyBase[S, T], Generic[S, T]):
                 # Update progress bar
                 self._update_progress_bar(progress_bar, len(to_call))
 
+            # Move to next batch
+            i += current_batch_size
+
         # Process any remaining items
         while pending_to_call:
-            to_call = pending_to_call[:batch_size]
-            pending_to_call = pending_to_call[batch_size:]
+            # Get dynamic batch size for remaining items
+            remaining_batch_size = self._normalized_batch_size(len(pending_to_call))
+            to_call = pending_to_call[:remaining_batch_size]
+            pending_to_call = pending_to_call[remaining_batch_size:]
 
             try:
-                results = map_func(to_call)
+                with self.suggester.record(len(to_call)):
+                    results = map_func(to_call)
             except Exception:
                 self.__finalize_failure(to_call)
                 raise
@@ -430,7 +444,7 @@ class BatchingMapProxy(ProxyBase[S, T], Generic[S, T]):
         if self.__all_cached(items):
             return self.__values(items)
 
-        unique_items = self.__unique_in_order(items)
+        unique_items = self._unique_in_order(items)
         owned, wait_for = self.__acquire_ownership(unique_items)
 
         self.__process_owned(owned, map_func)
@@ -465,6 +479,7 @@ class AsyncBatchingMapProxy(ProxyBase[S, T], Generic[S, T]):
     batch_size: Optional[int] = None
     max_concurrency: int = 8
     show_progress: bool = False
+    suggester: BatchSizeSuggester = field(default_factory=BatchSizeSuggester, repr=False)
 
     # internals
     __cache: Dict[S, T] = field(default_factory=dict, repr=False)
@@ -490,14 +505,6 @@ class AsyncBatchingMapProxy(ProxyBase[S, T], Generic[S, T]):
         else:
             self.__sema = None
 
-    # ---- private helpers -------------------------------------------------
-    # expose base helpers under subclass private names for compatibility
-    __unique_in_order = staticmethod(ProxyBase._ProxyBase__unique_in_order)
-    __normalized_batch_size = ProxyBase._ProxyBase__normalized_batch_size
-    _create_progress_bar = ProxyBase._create_progress_bar
-    _update_progress_bar = ProxyBase._update_progress_bar
-    _close_progress_bar = ProxyBase._close_progress_bar
-
     async def __all_cached(self, items: List[S]) -> bool:
         """Check whether all items are present in the cache.
 
@@ -602,69 +609,43 @@ class AsyncBatchingMapProxy(ProxyBase[S, T], Generic[S, T]):
         await self.clear()
 
     async def __process_owned(self, owned: List[S], map_func: Callable[[List[S]], Awaitable[List[T]]]) -> None:
-        """Process owned keys in mini-batches, re-checking cache before awaits.
-
-        Before calling ``map_func`` for each batch, the cache is re-checked to
-        skip any keys that may have been filled in the meantime. Items
-        are accumulated across multiple original batches to maximize batch
-        size utilization when some items are cached. On exceptions raised
-        by ``map_func``, all corresponding in-flight events are released
-        to prevent deadlocks, and the exception is propagated.
+        """Process owned keys using Producer-Consumer pattern with dynamic batch sizing.
 
         Args:
-            owned (list[S]): Items for which this coroutine holds computation
-            ownership.
+            owned (list[S]): Items for which this coroutine holds computation ownership.
 
         Raises:
             Exception: Propagates any exception raised by ``map_func``.
         """
         if not owned:
             return
-        batch_size = self.__normalized_batch_size(len(owned))
 
-        # Accumulate uncached items to maximize batch size utilization
-        pending_to_call: List[S] = []
-
-        # Setup progress bar
         progress_bar = self._create_progress_bar(len(owned))
+        batch_queue: asyncio.Queue = asyncio.Queue(maxsize=self.max_concurrency)
+
+        async def producer():
+            index = 0
+            while index < len(owned):
+                batch_size = self._normalized_batch_size(len(owned) - index)
+                batch = owned[index : index + batch_size]
+                await batch_queue.put(batch)
+                index += batch_size
+            # Send completion signals
+            for _ in range(self.max_concurrency):
+                await batch_queue.put(None)
+
+        async def consumer():
+            while True:
+                batch = await batch_queue.get()
+                try:
+                    if batch is None:
+                        break
+                    await self.__process_single_batch(batch, map_func, progress_bar)
+                finally:
+                    batch_queue.task_done()
 
-        # Collect all batches to process
-        batches_to_process: List[List[S]] = []
-
-        for i in range(0, len(owned), batch_size):
-            batch = owned[i : i + batch_size]
-            async with self.__lock:
-                uncached_in_batch = [x for x in batch if x not in self.__cache]
-
-            pending_to_call.extend(uncached_in_batch)
-
-            # Process accumulated items when we reach batch_size or at the end
-            is_last_batch = i + batch_size >= len(owned)
-            if len(pending_to_call) >= batch_size or (is_last_batch and pending_to_call):
-                # Take up to batch_size items to process
-                to_call = pending_to_call[:batch_size]
-                pending_to_call = pending_to_call[batch_size:]
-                if to_call:  # Only add non-empty batches
-                    batches_to_process.append(to_call)
-
-        # Process any remaining items
-        while pending_to_call:
-            to_call = pending_to_call[:batch_size]
-            pending_to_call = pending_to_call[batch_size:]
-            if to_call:  # Only add non-empty batches
-                batches_to_process.append(to_call)
-
-        # Process all batches concurrently
-        if batches_to_process:
-            tasks = []
-            for batch in batches_to_process:
-                task = self.__process_single_batch(batch, map_func, progress_bar)
-                tasks.append(task)
-
-            # Wait for all batches to complete
-            await asyncio.gather(*tasks)
+        await asyncio.gather(producer(), *[consumer() for _ in range(self.max_concurrency)])
 
-        # Close progress bar
         self._close_progress_bar(progress_bar)
 
     async def __process_single_batch(
@@ -676,7 +657,9 @@ class AsyncBatchingMapProxy(ProxyBase[S, T], Generic[S, T]):
             if self.__sema:
                 await self.__sema.acquire()
                 acquired = True
-            results = await map_func(to_call)
+            # Measure async map_func execution using suggester
+            with self.suggester.record(len(to_call)):
+                results = await map_func(to_call)
         except Exception:
             await self.__finalize_failure(to_call)
             raise
@@ -737,7 +720,7 @@ class AsyncBatchingMapProxy(ProxyBase[S, T], Generic[S, T]):
         if await self.__all_cached(items):
             return await self.__values(items)
 
-        unique_items = self.__unique_in_order(items)
+        unique_items = self._unique_in_order(items)
         owned, wait_for = await self.__acquire_ownership(unique_items)
 
         await self.__process_owned(owned, map_func)