openaivec 0.13.4__py3-none-any.whl → 0.13.6__py3-none-any.whl

openaivec/spark.py

@@ -115,7 +115,7 @@ Note: This module provides asynchronous support through the pandas extensions.
 import asyncio
 import logging
 from enum import Enum
-from typing import Dict, Iterator, List, Optional, Type, Union, get_args, get_origin
+from typing import Dict, Iterator, List, Type, Union, get_args, get_origin
 
 import numpy as np
 import pandas as pd
@@ -198,7 +198,7 @@ def _pydantic_to_spark_schema(model: Type[BaseModel]) -> StructType:
     return StructType(fields)
 
 
-def _safe_cast_str(x: Optional[str]) -> Optional[str]:
+def _safe_cast_str(x: str | None) -> str | None:
     try:
         if x is None:
             return None
@@ -209,7 +209,7 @@ def _safe_cast_str(x: Optional[str]) -> Optional[str]:
         return None
 
 
-def _safe_dump(x: Optional[BaseModel]) -> Dict:
+def _safe_dump(x: BaseModel | None) -> Dict:
     try:
         if x is None:
             return {}
@@ -224,7 +224,7 @@ def responses_udf(
     instructions: str,
     response_format: Type[ResponseFormat] = str,
     model_name: str = "gpt-4.1-mini",
-    batch_size: int = 128,
+    batch_size: int | None = None,
     temperature: float | None = 0.0,
     top_p: float = 1.0,
     max_concurrency: int = 8,
@@ -255,9 +255,11 @@ def responses_udf(
             or a Pydantic `BaseModel` for structured JSON output. Defaults to `str`.
         model_name (str): For Azure OpenAI, use your deployment name (e.g., "my-gpt4-deployment").
             For OpenAI, use the model name (e.g., "gpt-4.1-mini"). Defaults to "gpt-4.1-mini".
-        batch_size (int): Number of rows per async batch request within each partition.
+        batch_size (int | None): Number of rows per async batch request within each partition.
             Larger values reduce API call overhead but increase memory usage.
-            Recommended: 32-128 depending on data complexity. Defaults to 128.
+            Defaults to None (automatic batch size optimization that dynamically
+            adjusts based on execution time, targeting 30-60 seconds per batch).
+            Set to a positive integer (e.g., 32-128) for fixed batch size.
         temperature (float): Sampling temperature (0.0 to 2.0). Defaults to 0.0.
         top_p (float): Nucleus sampling parameter. Defaults to 1.0.
         max_concurrency (int): Maximum number of concurrent API requests **PER EXECUTOR**.
@@ -284,7 +286,7 @@ def responses_udf(
         spark_schema = _pydantic_to_spark_schema(response_format)
         json_schema_string = serialize_base_model(response_format)
 
-        @pandas_udf(returnType=spark_schema)
+        @pandas_udf(returnType=spark_schema)  # type: ignore[call-overload]
         def structure_udf(col: Iterator[pd.Series]) -> Iterator[pd.DataFrame]:
             pandas_ext.responses_model(model_name)
             response_format = deserialize_base_model(json_schema_string)
@@ -306,13 +308,13 @@ def responses_udf(
                     )
                     yield pd.DataFrame(predictions.map(_safe_dump).tolist())
             finally:
-                cache.clear()
+                asyncio.run(cache.clear())
 
-        return structure_udf
+        return structure_udf  # type: ignore[return-value]
 
     elif issubclass(response_format, str):
 
-        @pandas_udf(returnType=StringType())
+        @pandas_udf(returnType=StringType())  # type: ignore[call-overload]
         def string_udf(col: Iterator[pd.Series]) -> Iterator[pd.Series]:
             pandas_ext.responses_model(model_name)
             cache = AsyncBatchingMapProxy[str, str](
@@ -333,18 +335,18 @@ def responses_udf(
                     )
                     yield predictions.map(_safe_cast_str)
             finally:
-                cache.clear()
+                asyncio.run(cache.clear())
 
-        return string_udf
+        return string_udf  # type: ignore[return-value]
 
     else:
         raise ValueError(f"Unsupported response_format: {response_format}")
 
 
 def task_udf(
-    task: PreparedTask,
+    task: PreparedTask[ResponseFormat],
     model_name: str = "gpt-4.1-mini",
-    batch_size: int = 128,
+    batch_size: int | None = None,
     max_concurrency: int = 8,
 ) -> UserDefinedFunction:
     """Create an asynchronous Spark pandas UDF from a predefined task.
@@ -360,9 +362,11 @@ def task_udf(
             response format, temperature, and top_p settings.
         model_name (str): For Azure OpenAI, use your deployment name (e.g., "my-gpt4-deployment").
             For OpenAI, use the model name (e.g., "gpt-4.1-mini"). Defaults to "gpt-4.1-mini".
-        batch_size (int): Number of rows per async batch request within each partition.
+        batch_size (int | None): Number of rows per async batch request within each partition.
             Larger values reduce API call overhead but increase memory usage.
-            Recommended: 32-128 depending on task complexity. Defaults to 128.
+            Defaults to None (automatic batch size optimization that dynamically
+            adjusts based on execution time, targeting 30-60 seconds per batch).
+            Set to a positive integer (e.g., 32-128) for fixed batch size.
         max_concurrency (int): Maximum number of concurrent API requests **PER EXECUTOR**.
             Total cluster concurrency = max_concurrency × number_of_executors.
             Higher values increase throughput but may hit OpenAI rate limits.
@@ -399,7 +403,7 @@ def task_udf(
         response_format = deserialize_base_model(task_response_format_json)
         spark_schema = _pydantic_to_spark_schema(response_format)
 
-        @pandas_udf(returnType=spark_schema)
+        @pandas_udf(returnType=spark_schema)  # type: ignore[call-overload]
         def task_udf(col: Iterator[pd.Series]) -> Iterator[pd.DataFrame]:
             pandas_ext.responses_model(model_name)
             cache = AsyncBatchingMapProxy[str, response_format](
@@ -420,13 +424,13 @@ def task_udf(
                     )
                     yield pd.DataFrame(predictions.map(_safe_dump).tolist())
             finally:
-                cache.clear()
+                asyncio.run(cache.clear())
 
-        return task_udf
+        return task_udf  # type: ignore[return-value]
 
     elif issubclass(task.response_format, str):
 
-        @pandas_udf(returnType=StringType())
+        @pandas_udf(returnType=StringType())  # type: ignore[call-overload]
         def task_string_udf(col: Iterator[pd.Series]) -> Iterator[pd.Series]:
             pandas_ext.responses_model(model_name)
             cache = AsyncBatchingMapProxy[str, str](
@@ -447,16 +451,16 @@ def task_udf(
                     )
                     yield predictions.map(_safe_cast_str)
             finally:
-                cache.clear()
+                asyncio.run(cache.clear())
 
-        return task_string_udf
+        return task_string_udf  # type: ignore[return-value]
 
     else:
         raise ValueError(f"Unsupported response_format in task: {task.response_format}")
 
 
 def embeddings_udf(
-    model_name: str = "text-embedding-3-small", batch_size: int = 128, max_concurrency: int = 8
+    model_name: str = "text-embedding-3-small", batch_size: int | None = None, max_concurrency: int = 8
 ) -> UserDefinedFunction:
     """Create an asynchronous Spark pandas UDF for generating embeddings.
 
@@ -481,10 +485,12 @@ def embeddings_udf(
     Args:
         model_name (str): For Azure OpenAI, use your deployment name (e.g., "my-embedding-deployment").
             For OpenAI, use the model name (e.g., "text-embedding-3-small"). Defaults to "text-embedding-3-small".
-        batch_size (int): Number of rows per async batch request within each partition.
+        batch_size (int | None): Number of rows per async batch request within each partition.
             Larger values reduce API call overhead but increase memory usage.
+            Defaults to None (automatic batch size optimization that dynamically
+            adjusts based on execution time, targeting 30-60 seconds per batch).
+            Set to a positive integer (e.g., 64-256) for fixed batch size.
             Embeddings typically handle larger batches efficiently.
-            Recommended: 64-256 depending on text length. Defaults to 128.
         max_concurrency (int): Maximum number of concurrent API requests **PER EXECUTOR**.
             Total cluster concurrency = max_concurrency × number_of_executors.
             Higher values increase throughput but may hit OpenAI rate limits.
@@ -505,7 +511,7 @@ def embeddings_udf(
         - Use larger batch_size for embeddings compared to response generation
     """
 
-    @pandas_udf(returnType=ArrayType(FloatType()))
+    @pandas_udf(returnType=ArrayType(FloatType()))  # type: ignore[call-overload,misc]
     def _embeddings_udf(col: Iterator[pd.Series]) -> Iterator[pd.Series]:
         pandas_ext.embeddings_model(model_name)
         cache = AsyncBatchingMapProxy[str, np.ndarray](
@@ -518,9 +524,9 @@ def embeddings_udf(
                 embeddings: pd.Series = asyncio.run(part.aio.embeddings_with_cache(cache=cache))
                 yield embeddings.map(lambda x: x.tolist())
         finally:
-            cache.clear()
+            asyncio.run(cache.clear())
 
-    return _embeddings_udf
+    return _embeddings_udf  # type: ignore[return-value]
 
 
 def split_to_chunks_udf(max_tokens: int, sep: List[str]) -> UserDefinedFunction:
@@ -535,7 +541,7 @@ def split_to_chunks_udf(max_tokens: int, sep: List[str]) -> UserDefinedFunction:
             values are lists of chunks respecting the ``max_tokens`` limit.
     """
 
-    @pandas_udf(ArrayType(StringType()))
+    @pandas_udf(ArrayType(StringType()))  # type: ignore[call-overload,misc]
     def fn(col: Iterator[pd.Series]) -> Iterator[pd.Series]:
         encoding = tiktoken.get_encoding("o200k_base")
         chunker = TextChunker(encoding)
@@ -543,7 +549,7 @@ def split_to_chunks_udf(max_tokens: int, sep: List[str]) -> UserDefinedFunction:
         for part in col:
             yield part.map(lambda x: chunker.split(x, max_tokens=max_tokens, sep=sep) if isinstance(x, str) else [])
 
-    return fn
+    return fn  # type: ignore[return-value]
 
 
 def count_tokens_udf() -> UserDefinedFunction:
@@ -556,18 +562,18 @@ def count_tokens_udf() -> UserDefinedFunction:
         A pandas UDF producing an ``IntegerType`` column with token counts.
     """
 
-    @pandas_udf(IntegerType())
+    @pandas_udf(IntegerType())  # type: ignore[call-overload]
     def fn(col: Iterator[pd.Series]) -> Iterator[pd.Series]:
         encoding = tiktoken.get_encoding("o200k_base")
 
         for part in col:
             yield part.map(lambda x: len(encoding.encode(x)) if isinstance(x, str) else 0)
 
-    return fn
+    return fn  # type: ignore[return-value]
 
 
 def similarity_udf() -> UserDefinedFunction:
-    @pandas_udf(FloatType())
+    @pandas_udf(FloatType())  # type: ignore[call-overload]
     def fn(a: pd.Series, b: pd.Series) -> pd.Series:
         """Compute cosine similarity between two vectors.
 
@@ -583,4 +589,4 @@ def similarity_udf() -> UserDefinedFunction:
 
         return pd.DataFrame({"a": a, "b": b}).ai.similarity("a", "b")
 
-    return fn
+    return fn  # type: ignore[return-value]

openaivec/task/customer_support/inquiry_classification.py

@@ -92,7 +92,7 @@ Example:
     ```
 """
 
-from typing import Dict, List, Literal, Optional
+from typing import Dict, List, Literal
 
 from pydantic import BaseModel, Field
 
@@ -114,25 +114,25 @@ class InquiryClassification(BaseModel):
 
 
 def inquiry_classification(
-    categories: Optional[Dict[str, List[str]]] = None,
-    routing_rules: Optional[Dict[str, str]] = None,
-    priority_rules: Optional[Dict[str, str]] = None,
+    categories: Dict[str, List[str]] | None = None,
+    routing_rules: Dict[str, str] | None = None,
+    priority_rules: Dict[str, str] | None = None,
     business_context: str = "general customer support",
-    custom_keywords: Optional[Dict[str, List[str]]] = None,
+    custom_keywords: Dict[str, List[str]] | None = None,
     temperature: float = 0.0,
     top_p: float = 1.0,
 ) -> PreparedTask:
     """Create a configurable inquiry classification task.
 
     Args:
-        categories (Optional[Dict[str, List[str]]]): Dictionary mapping category names to lists of subcategories.
+        categories (Dict[str, List[str]] | None): Dictionary mapping category names to lists of subcategories.
             Default provides standard support categories.
-        routing_rules (Optional[Dict[str, str]]): Dictionary mapping categories to routing destinations.
+        routing_rules (Dict[str, str] | None): Dictionary mapping categories to routing destinations.
             Default provides standard routing options.
-        priority_rules (Optional[Dict[str, str]]): Dictionary mapping keywords/patterns to priority levels.
+        priority_rules (Dict[str, str] | None): Dictionary mapping keywords/patterns to priority levels.
             Default uses standard priority indicators.
         business_context (str): Description of the business context to help with classification.
-        custom_keywords (Optional[Dict[str, List[str]]]): Dictionary mapping categories to relevant keywords.
+        custom_keywords (Dict[str, List[str]] | None): Dictionary mapping categories to relevant keywords.
         temperature (float): Sampling temperature (0.0-1.0).
         top_p (float): Nucleus sampling parameter (0.0-1.0).
 

openaivec/task/customer_support/urgency_analysis.py

@@ -96,7 +96,7 @@ Example:
     ```
 """
 
-from typing import Dict, List, Literal, Optional
+from typing import Dict, List, Literal
 
 from pydantic import BaseModel, Field
 
@@ -127,28 +127,28 @@ class UrgencyAnalysis(BaseModel):
 
 
 def urgency_analysis(
-    urgency_levels: Optional[Dict[str, str]] = None,
-    response_times: Optional[Dict[str, str]] = None,
-    customer_tiers: Optional[Dict[str, str]] = None,
-    escalation_rules: Optional[Dict[str, str]] = None,
-    urgency_keywords: Optional[Dict[str, List[str]]] = None,
+    urgency_levels: Dict[str, str] | None = None,
+    response_times: Dict[str, str] | None = None,
+    customer_tiers: Dict[str, str] | None = None,
+    escalation_rules: Dict[str, str] | None = None,
+    urgency_keywords: Dict[str, List[str]] | None = None,
     business_context: str = "general customer support",
     business_hours: str = "24/7 support",
-    sla_rules: Optional[Dict[str, str]] = None,
+    sla_rules: Dict[str, str] | None = None,
     temperature: float = 0.0,
     top_p: float = 1.0,
 ) -> PreparedTask:
     """Create a configurable urgency analysis task.
 
     Args:
-        urgency_levels (Optional[Dict[str, str]]): Dictionary mapping urgency levels to descriptions.
-        response_times (Optional[Dict[str, str]]): Dictionary mapping urgency levels to response times.
-        customer_tiers (Optional[Dict[str, str]]): Dictionary mapping tier names to descriptions.
-        escalation_rules (Optional[Dict[str, str]]): Dictionary mapping conditions to escalation actions.
-        urgency_keywords (Optional[Dict[str, List[str]]]): Dictionary mapping urgency levels to indicator keywords.
+        urgency_levels (Dict[str, str] | None): Dictionary mapping urgency levels to descriptions.
+        response_times (Dict[str, str] | None): Dictionary mapping urgency levels to response times.
+        customer_tiers (Dict[str, str] | None): Dictionary mapping tier names to descriptions.
+        escalation_rules (Dict[str, str] | None): Dictionary mapping conditions to escalation actions.
+        urgency_keywords (Dict[str, List[str]] | None): Dictionary mapping urgency levels to indicator keywords.
         business_context (str): Description of the business context.
         business_hours (str): Description of business hours for response time calculation.
-        sla_rules (Optional[Dict[str, str]]): Dictionary mapping customer tiers to SLA requirements.
+        sla_rules (Dict[str, str] | None): Dictionary mapping customer tiers to SLA requirements.
         temperature (float): Sampling temperature (0.0-1.0).
         top_p (float): Nucleus sampling parameter (0.0-1.0).
 

openaivec/task/nlp/keyword_extraction.py

@@ -50,7 +50,7 @@ Attributes:
         top_p=1.0 for deterministic output.
 """
 
-from typing import List, Optional
+from typing import List
 
 from pydantic import BaseModel, Field
 
@@ -63,7 +63,7 @@ class Keyword(BaseModel):
     text: str = Field(description="The keyword or phrase")
     score: float = Field(description="Importance score (0.0-1.0)")
     frequency: int = Field(description="Frequency of occurrence in the text")
-    context: Optional[str] = Field(description="Context where the keyword appears")
+    context: str | None = Field(description="Context where the keyword appears")
 
 
 class KeywordExtraction(BaseModel):

openaivec/task/nlp/named_entity_recognition.py

@@ -48,7 +48,7 @@ Attributes:
         top_p=1.0 for deterministic output.
 """
 
-from typing import List, Optional
+from typing import List
 
 from pydantic import BaseModel, Field
 
@@ -62,7 +62,7 @@ class NamedEntity(BaseModel):
     label: str = Field(description="Entity type label")
     start: int = Field(description="Start position in the original text")
     end: int = Field(description="End position in the original text")
-    confidence: Optional[float] = Field(description="Confidence score (0.0-1.0)")
+    confidence: float | None = Field(description="Confidence score (0.0-1.0)")
 
 
 class NamedEntityRecognition(BaseModel):

openaivec/util.py

@@ -82,7 +82,7 @@ def backoff(
 
         return wrapper
 
-    return decorator
+    return decorator  # type: ignore[return-value]
 
 
 def backoff_async(
@@ -134,7 +134,7 @@ def backoff_async(
 
         return wrapper
 
-    return decorator
+    return decorator  # type: ignore[return-value]
 
 
 @dataclass(frozen=True)

{openaivec-0.13.4.dist-info → openaivec-0.13.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openaivec
-Version: 0.13.4
+Version: 0.13.6
 Summary: Generative mutation for tabular calculation
 Project-URL: Homepage, https://microsoft.github.io/openaivec/
 Project-URL: Repository, https://github.com/microsoft/openaivec
@@ -159,7 +159,7 @@ 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.",
-    batch_size=32,
+    # batch_size defaults to None (automatic optimization)
 )
 
 result = client.parse(["panda", "rabbit", "koala"])
@@ -304,7 +304,7 @@ async def process_data():
     # Asynchronous processing with fine-tuned concurrency control
     results = await df["text"].aio.responses(
         "Analyze sentiment and classify as positive/negative/neutral",
-        batch_size=64,        # Process 64 items per API request
+        # batch_size defaults to None (automatic optimization)
         max_concurrency=12    # Allow up to 12 concurrent requests
     )
     return results
@@ -315,7 +315,7 @@ sentiments = asyncio.run(process_data())
 
 **Key Parameters for Performance Tuning:**
 
-- **`batch_size`** (default: 128): Controls how many inputs are grouped into a single API request. Higher values reduce API call overhead but increase memory usage and request processing time.
+- **`batch_size`** (default: None): Controls how many inputs are grouped into a single API request. When None (default), automatic batch size optimization adjusts based on execution time. Set to a positive integer for fixed batch size. Higher values reduce API call overhead but increase memory usage and request processing time.
 - **`max_concurrency`** (default: 8): Limits the number of concurrent API requests. Higher values increase throughput but may hit rate limits or overwhelm the API.
 
 **Performance Benefits:**
@@ -460,12 +460,12 @@ When using openaivec with Spark, proper configuration of `batch_size` and `max_c
 - **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):
+**`batch_size`** (default: None):
 
 - Controls how many rows are processed together in each API request within a partition
-- **Larger values**: Fewer API calls per partition, reduced overhead
-- **Smaller values**: More granular processing, better memory management
-- **Recommendation**: 32-128 depending on data complexity and partition size
+- **Default (None)**: Automatic batch size optimization adjusts based on execution time
+- **Positive integer**: Fixed batch size - larger values reduce API calls but increase memory usage
+- **Recommendation**: Use default automatic optimization, or set 32-128 for fixed batch size
 
 **`max_concurrency`** (default: 8):
 
@@ -483,7 +483,7 @@ spark.udf.register(
     "analyze_sentiment",
     responses_udf(
         instructions="Analyze sentiment as positive/negative/neutral",
-        batch_size=64,        # Good balance for most use cases
+        # batch_size defaults to None (automatic optimization)
         max_concurrency=8     # 80 total concurrent requests across cluster
     )
 )

{openaivec-0.13.4.dist-info → openaivec-0.13.6.dist-info}/RECORD

@@ -1,35 +1,35 @@
 openaivec/__init__.py,sha256=DQcfTw7y4CgPtyyMg-wO4chwVYT0jA_F-EjxT_bXxTg,236
 openaivec/di.py,sha256=eNewaSRx7f_O0IQcyjzGpIMak6O-bc6OeMqjytCfr88,10634
-openaivec/embeddings.py,sha256=ypED2-MkC6t4Fvuopeldab8kNoR3-hN8BLVzRPDaWhk,7210
+openaivec/embeddings.py,sha256=ntnsdV2L6WAT4nKqgL3MZfhqf_Xnfu_J8oFavjIVcIU,7470
 openaivec/log.py,sha256=GofgzUpv_xDVuGC-gYmit5Oyu06it1SBXRck6COR5go,1439
-openaivec/model.py,sha256=wu1UGetqLbUGvGqmOiQna4SJnO5VvyMoCHdAQhSG6MY,3295
-openaivec/optimize.py,sha256=-9h03O_bDjtHYHg5L9M76gmaEddkE87HmN964XCO4bU,3838
-openaivec/pandas_ext.py,sha256=H4DswYgfTf0NrBl-L1LgR78ZIfgHONs3YIEWptahh8U,56361
-openaivec/prompt.py,sha256=3-fcmFW-yroKL_Yt-wE0u1FwZ22ja8ul3o6Llhefzzo,18544
-openaivec/provider.py,sha256=kkC9eYgXRUwb88EvN4dhEc00FDKT3l5D_ZDsW0Ty7SM,6218
-openaivec/proxy.py,sha256=Y-ig4hEf_r0sBvb0fuKqvUkT2hFRV3Zj_6mSu9yphrs,28113
-openaivec/responses.py,sha256=_465ufTtA58DwI5KQg9YIkEfLT0XYHvyWSZfjU8hNSs,20457
+openaivec/model.py,sha256=u1zQLF__Qw9mp92K1LYaAaQEYisMZoMWuX9-dx2JYoE,3316
+openaivec/optimize.py,sha256=jjE-_ZOs_BPuSHHYVoykGHqTF04nlYkz_rFZ0Kcwtdc,3837
+openaivec/pandas_ext.py,sha256=QlTSZkVzVwO1MFAGv_MuFaINpXlxYjkbfO0zCsmbmSM,58717
+openaivec/prompt.py,sha256=ZzHOS2CRLRtPeP4Z734xkaAA5LFcfmhkDQE5URQUidQ,20842
+openaivec/provider.py,sha256=BYsJxioaemDpjOYdNuLMtasi54Je6LNrtyYupHTxWLA,6688
+openaivec/proxy.py,sha256=jsWUqEJVlRHj0854GlvAzG09mm-QmFFNREXeMOc1LsY,28901
+openaivec/responses.py,sha256=v4MtyIh_g6bahmkq1Ra4y63Tlqg6-Ace1SErmoosvMg,21424
 openaivec/serialize.py,sha256=HXi5l_4b_4eUMNL7f7o_suyHHF_hz3RYsUsri5CQ7_4,7325
-openaivec/spark.py,sha256=ZCoR5_7FKX_fC_rhV6X9N4lQ927nLScEKVqhFYGkiWU,23169
-openaivec/util.py,sha256=dnzFFbeQFNTq2FkJQbAKyunvUqEpLlRy9q3EtBDPS_k,6349
+openaivec/spark.py,sha256=uxXXgOhH1g_HEnBIuNGLlKPInJwZBCLaqrTnJT2UHk4,24252
+openaivec/util.py,sha256=A7-QSoGkdllH6e6CVHxuGk-fmAmsSCSZVSJ5VSDzmx4,6409
 openaivec/task/__init__.py,sha256=26Kd2eRRfUqRJnYH83sRrbuEuRwshypRRSkTWtT50Tw,6177
 openaivec/task/customer_support/__init__.py,sha256=KWfGyXPdZyfGdRH17x7hPpJJ1N2EP9PPhZx0fvBAwSI,884
 openaivec/task/customer_support/customer_sentiment.py,sha256=vf2GzUk_06JD1FeRTetg5bCcBFUSqH349J1TI5lsgkg,7616
-openaivec/task/customer_support/inquiry_classification.py,sha256=SxsgBXk1Qqg-2rg2VGyfXy_wcK2eS5EhJt7p9FYwfzw,9678
+openaivec/task/customer_support/inquiry_classification.py,sha256=F86-wBMjHn_PtUDT9N6LHmxRGkYMd3huT-KrqZAogCg,9644
 openaivec/task/customer_support/inquiry_summary.py,sha256=bZV8pvPAdiijqMnaUMg_jGie0dsEHgnEUvqhunyP0CY,6924
 openaivec/task/customer_support/intent_analysis.py,sha256=i8S19z_-Dgz9rspiDTE0TShmExYE9y6ZCr8ipmHvC4A,7508
 openaivec/task/customer_support/response_suggestion.py,sha256=L3NJLqyFafxEsW3QD0MIiE-MB4akwoDW6nuWOWJQpyE,8348
-openaivec/task/customer_support/urgency_analysis.py,sha256=Ltgc1CWrEoPkp-sxZXipmU3ufFDsmhMOC6dxSrcofJo,11619
+openaivec/task/customer_support/urgency_analysis.py,sha256=_llRrS11BJ392Xz0dXqr5i1jggTjgvtpKDEwUoY2KaE,11573
 openaivec/task/nlp/__init__.py,sha256=QoQ0egEK9IEh5hdrE07rZ_KCmC0gy_2FPrWJYRWiipY,512
 openaivec/task/nlp/dependency_parsing.py,sha256=7JczHzibWARPwo7h81N2Qk9h-3AnLmMkVsJ1cZp1w6Q,2840
-openaivec/task/nlp/keyword_extraction.py,sha256=nbn-YMJXDbhuvyl438aMn3LSTPEC362bUafcwLtaBxE,2840
+openaivec/task/nlp/keyword_extraction.py,sha256=bPI0mYzgZ3pXEBusOpSpoi_Zs84ccQXknS_nB7Bwy7I,2827
 openaivec/task/nlp/morphological_analysis.py,sha256=DvJhJge7r_oEYfb0Siq-x9rioCWYBVw6wroTdGkqInk,2424
-openaivec/task/nlp/named_entity_recognition.py,sha256=ibXFiTxpcGksdugiP9kWilDUcMofUrQeq_gMm9mZ1UE,3073
+openaivec/task/nlp/named_entity_recognition.py,sha256=ehT1SYGsBrviPLVKk2veMKoxdS4CTx89FefAwN2jA4s,3060
 openaivec/task/nlp/sentiment_analysis.py,sha256=9HdMpi7FkjHNXAswaN98k8jeKsatBBXTPaTmp9VI7mE,3089
 openaivec/task/nlp/translation.py,sha256=4fjKtbVvOvivWMrpZfreIsdg8d0DplDujO8kAdLbAKI,6625
 openaivec/task/table/__init__.py,sha256=kJz15WDJXjyC7UIHKBvlTRhCf347PCDMH5T5fONV2sU,83
 openaivec/task/table/fillna.py,sha256=vi8t5QEIU-W3e05wwpATb3MEUDyf8luVnE8U-5VebZo,6582
-openaivec-0.13.4.dist-info/METADATA,sha256=86Y8Pmh1y3cTTxKx9OWNRl5xwY3AAV8AHlAsZ80FHv4,27329
-openaivec-0.13.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-openaivec-0.13.4.dist-info/licenses/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
-openaivec-0.13.4.dist-info/RECORD,,
+openaivec-0.13.6.dist-info/METADATA,sha256=JDjFmGAcoqSIeoK5JSEQ0Kd98HVRHW_DPwiUvsheDIU,27566
+openaivec-0.13.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+openaivec-0.13.6.dist-info/licenses/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
+openaivec-0.13.6.dist-info/RECORD,,