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

openaivec/task/customer_support/urgency_analysis.py

@@ -5,26 +5,26 @@ inquiries to help prioritize support queue and response times.
 
 Example:
     Basic usage with default settings:
-    
+
     ```python
     from openai import OpenAI
-    from openaivec.responses import BatchResponses
+    from openaivec import BatchResponses
     from openaivec.task import customer_support
-    
+
     client = OpenAI()
     analyzer = BatchResponses.of_task(
         client=client,
-        model_name="gpt-4o-mini",
+        model_name="gpt-4.1-mini",
         task=customer_support.urgency_analysis()
     )
-    
+
     inquiries = [
         "URGENT: My website is down and I'm losing customers!",
         "Can you help me understand how to use the new feature?",
         "I haven't received my order from last week"
     ]
     analyses = analyzer.parse(inquiries)
-    
+
     for analysis in analyses:
         print(f"Urgency Level: {analysis.urgency_level}")
         print(f"Score: {analysis.urgency_score}")
@@ -33,10 +33,10 @@ Example:
     ```
 
     Customized for SaaS platform with business hours:
-    
+
     ```python
     from openaivec.task import customer_support
-    
+
     # SaaS-specific urgency levels
     saas_urgency_levels = {
         "critical": "Service outages, security breaches, data loss",
@@ -44,15 +44,15 @@ Example:
         "medium": "Feature bugs, performance issues, billing questions",
         "low": "Feature requests, documentation questions, general feedback"
     }
-    
+
     # Custom response times based on SLA
     saas_response_times = {
         "critical": "immediate",
         "high": "within_1_hour",
-        "medium": "within_4_hours", 
+        "medium": "within_4_hours",
         "low": "within_24_hours"
     }
-    
+
     # Enterprise customer tier gets priority
     enterprise_customer_tiers = {
         "enterprise": "Priority support, dedicated account manager",
@@ -60,7 +60,7 @@ Example:
         "professional": "Professional plan support",
         "starter": "Basic support"
     }
-    
+
     task = customer_support.urgency_analysis(
         urgency_levels=saas_urgency_levels,
         response_times=saas_response_times,
@@ -68,168 +68,174 @@ Example:
         business_context="SaaS platform",
         business_hours="9 AM - 5 PM EST, Monday-Friday"
     )
-    
+
     analyzer = BatchResponses.of_task(
         client=client,
-        model_name="gpt-4o-mini",
+        model_name="gpt-4.1-mini",
         task=task
     )
     ```
 
     With pandas integration:
-    
+
     ```python
     import pandas as pd
     from openaivec import pandas_ext  # Required for .ai accessor
     from openaivec.task import customer_support
-    
+
     df = pd.DataFrame({"inquiry": [
         "URGENT: My website is down and I'm losing customers!",
         "Can you help me understand how to use the new feature?",
         "I haven't received my order from last week"
     ]})
     df["urgency"] = df["inquiry"].ai.task(customer_support.urgency_analysis())
-    
+
     # Extract urgency components
     extracted_df = df.ai.extract("urgency")
     print(extracted_df[["inquiry", "urgency_urgency_level", "urgency_urgency_score", "urgency_response_time"]])
     ```
 """
 
-from typing import List, Dict, Optional, Literal
+from typing import Dict, Literal
+
 from pydantic import BaseModel, Field
 
-from ..model import PreparedTask
+from openaivec._model import PreparedTask
 
 __all__ = ["urgency_analysis"]
 
 
 class UrgencyAnalysis(BaseModel):
-    urgency_level: Literal["critical", "high", "medium", "low"] = Field(description="Urgency level from configured levels (critical, high, medium, low)")
+    urgency_level: Literal["critical", "high", "medium", "low"] = Field(
+        description="Urgency level from configured levels (critical, high, medium, low)"
+    )
     urgency_score: float = Field(description="Urgency score from 0.0 (not urgent) to 1.0 (extremely urgent)")
-    response_time: Literal["immediate", "within_1_hour", "within_4_hours", "within_24_hours"] = Field(description="Recommended response time from configured times (immediate, within_1_hour, within_4_hours, within_24_hours)")
+    response_time: Literal["immediate", "within_1_hour", "within_4_hours", "within_24_hours"] = Field(
+        description="Recommended response time from configured times "
+        "(immediate, within_1_hour, within_4_hours, within_24_hours)"
+    )
     escalation_required: bool = Field(description="Whether this inquiry requires escalation to management")
-    urgency_indicators: List[str] = Field(description="Specific words or phrases that indicate urgency")
-    business_impact: Literal["none", "low", "medium", "high", "critical"] = Field(description="Potential business impact (none, low, medium, high, critical)")
-    customer_tier: Literal["enterprise", "premium", "standard", "basic"] = Field(description="Inferred customer tier from configured tiers (enterprise, premium, standard, basic)")
+    urgency_indicators: list[str] = Field(description="Specific words or phrases that indicate urgency")
+    business_impact: Literal["none", "low", "medium", "high", "critical"] = Field(
+        description="Potential business impact (none, low, medium, high, critical)"
+    )
+    customer_tier: Literal["enterprise", "premium", "standard", "basic"] = Field(
+        description="Inferred customer tier from configured tiers (enterprise, premium, standard, basic)"
+    )
     reasoning: str = Field(description="Brief explanation of urgency assessment")
     sla_compliance: bool = Field(description="Whether response time aligns with SLA requirements")
 
 
 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,
-    temperature: float = 0.0,
-    top_p: float = 1.0
+    sla_rules: Dict[str, str] | None = None,
 ) -> PreparedTask:
     """Create a configurable urgency analysis task.
-    
+
     Args:
-        urgency_levels: Dictionary mapping urgency levels to descriptions.
-        response_times: Dictionary mapping urgency levels to response times.
-        customer_tiers: Dictionary mapping tier names to descriptions.
-        escalation_rules: Dictionary mapping conditions to escalation actions.
-        urgency_keywords: Dictionary mapping urgency levels to indicator keywords.
-        business_context: Description of the business context.
-        business_hours: Description of business hours for response time calculation.
-        sla_rules: Dictionary mapping customer tiers to SLA requirements.
-        temperature: Sampling temperature (0.0-1.0).
-        top_p: Nucleus sampling parameter (0.0-1.0).
-        
+        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 (dict[str, str] | None): Dictionary mapping customer tiers to SLA requirements.
+
     Returns:
         PreparedTask configured for urgency analysis.
     """
-    
+
     # Default urgency levels
     if urgency_levels is None:
         urgency_levels = {
             "critical": "Service outages, security breaches, data loss, system failures affecting business operations",
             "high": "Account locked, payment failures, urgent deadlines, angry customers, revenue-impacting issues",
             "medium": "Feature not working, delivery delays, billing questions, moderate customer frustration",
-            "low": "General questions, feature requests, feedback, compliments, minor issues"
+            "low": "General questions, feature requests, feedback, compliments, minor issues",
         }
-    
+
     # Default response times
     if response_times is None:
         response_times = {
             "critical": "immediate",
             "high": "within_1_hour",
             "medium": "within_4_hours",
-            "low": "within_24_hours"
+            "low": "within_24_hours",
         }
-    
+
     # Default customer tiers
     if customer_tiers is None:
         customer_tiers = {
             "enterprise": "Large contracts, multiple users, business-critical usage",
             "premium": "Paid plans, professional use, higher expectations",
             "standard": "Regular paid users, normal expectations",
-            "basic": "Free users, casual usage, lower priority"
+            "basic": "Free users, casual usage, lower priority",
         }
-    
+
     # Default escalation rules
     if escalation_rules is None:
         escalation_rules = {
             "immediate": "Critical issues, security breaches, service outages",
             "within_1_hour": "High urgency with customer tier enterprise or premium",
             "manager_review": "Threats to cancel, legal language, compliance issues",
-            "no_escalation": "Standard support can handle"
+            "no_escalation": "Standard support can handle",
         }
-    
+
     # Default urgency keywords
     if urgency_keywords is None:
         urgency_keywords = {
             "critical": ["urgent", "emergency", "critical", "down", "outage", "security", "breach", "immediate"],
             "high": ["ASAP", "urgent", "problem", "issue", "error", "bug", "frustrated", "angry"],
             "medium": ["question", "help", "support", "feedback", "concern", "delayed"],
-            "low": ["information", "thank", "compliment", "suggestion", "general", "when convenient"]
+            "low": ["information", "thank", "compliment", "suggestion", "general", "when convenient"],
         }
-    
+
     # Default SLA rules
     if sla_rules is None:
         sla_rules = {
             "enterprise": "Critical: 15min, High: 1hr, Medium: 4hr, Low: 24hr",
             "premium": "Critical: 30min, High: 2hr, Medium: 8hr, Low: 48hr",
             "standard": "Critical: 1hr, High: 4hr, Medium: 24hr, Low: 72hr",
-            "basic": "Critical: 4hr, High: 24hr, Medium: 72hr, Low: 1week"
+            "basic": "Critical: 4hr, High: 24hr, Medium: 72hr, Low: 1week",
         }
-    
+
     # Build urgency levels section
     urgency_text = "Urgency Levels:\n"
     for level, description in urgency_levels.items():
         urgency_text += f"- {level}: {description}\n"
-    
+
     # Build response times section
     response_text = "Response Times:\n"
     for level, time in response_times.items():
         response_text += f"- {level}: {time}\n"
-    
+
     # Build customer tiers section
     tiers_text = "Customer Tiers:\n"
     for tier, description in customer_tiers.items():
         tiers_text += f"- {tier}: {description}\n"
-    
+
     # Build escalation rules section
     escalation_text = "Escalation Rules:\n"
     for condition, action in escalation_rules.items():
         escalation_text += f"- {condition}: {action}\n"
-    
+
     # Build urgency keywords section
     keywords_text = "Urgency Keywords:\n"
     for level, keywords in urgency_keywords.items():
         keywords_text += f"- {level}: {', '.join(keywords)}\n"
-    
+
     # Build SLA rules section
     sla_text = "SLA Rules:\n"
     for tier, sla in sla_rules.items():
         sla_text += f"- {tier}: {sla}\n"
-    
+
     instructions = f"""Analyze the urgency level of the customer inquiry based on language, content, and context.
 
 Business Context: {business_context}
@@ -269,17 +275,16 @@ Consider:
 - Revenue or operational impact
 - Compliance or legal implications
 
-IMPORTANT: Provide analysis responses in the same language as the input text, except for the predefined categorical fields (urgency_level, response_time, business_impact, customer_tier) which must use the exact English values specified above. For example, if the input is in French, provide urgency_indicators and reasoning in French, but use English values like "critical" for urgency_level.
+IMPORTANT: Provide analysis responses in the same language as the input text, except for the
+predefined categorical fields (urgency_level, response_time, business_impact, customer_tier)
+which must use the exact English values specified above. For example, if the input is in French,
+provide urgency_indicators and reasoning in French, but use English values like "critical" for
+urgency_level.
 
 Provide detailed analysis with clear reasoning for urgency level and response time recommendations."""
 
-    return PreparedTask(
-        instructions=instructions,
-        response_format=UrgencyAnalysis,
-        temperature=temperature,
-        top_p=top_p
-    )
+    return PreparedTask(instructions=instructions, response_format=UrgencyAnalysis)
 
 
 # Backward compatibility - default configuration
-URGENCY_ANALYSIS = urgency_analysis()
+URGENCY_ANALYSIS = urgency_analysis()

openaivec/task/nlp/__init__.py

@@ -1,9 +1,9 @@
-from .translation import MULTILINGUAL_TRANSLATION
+from .dependency_parsing import DEPENDENCY_PARSING
+from .keyword_extraction import KEYWORD_EXTRACTION
 from .morphological_analysis import MORPHOLOGICAL_ANALYSIS
 from .named_entity_recognition import NAMED_ENTITY_RECOGNITION
 from .sentiment_analysis import SENTIMENT_ANALYSIS
-from .dependency_parsing import DEPENDENCY_PARSING
-from .keyword_extraction import KEYWORD_EXTRACTION
+from .translation import MULTILINGUAL_TRANSLATION
 
 __all__ = [
     "MULTILINGUAL_TRANSLATION",
@@ -12,4 +12,4 @@ __all__ = [
     "SENTIMENT_ANALYSIS",
     "DEPENDENCY_PARSING",
     "KEYWORD_EXTRACTION",
-]
+]

openaivec/task/nlp/dependency_parsing.py

@@ -5,22 +5,22 @@ syntactic dependencies between words in sentences using OpenAI's language models
 
 Example:
     Basic usage with BatchResponses:
-    
+
     ```python
     from openai import OpenAI
-    from openaivec.responses import BatchResponses
+    from openaivec import BatchResponses
     from openaivec.task import nlp
-    
+
     client = OpenAI()
     analyzer = BatchResponses.of_task(
         client=client,
-        model_name="gpt-4o-mini",
+        model_name="gpt-4.1-mini",
         task=nlp.DEPENDENCY_PARSING
     )
-    
+
     texts = ["The cat sat on the mat.", "She quickly ran to the store."]
     analyses = analyzer.parse(texts)
-    
+
     for analysis in analyses:
         print(f"Tokens: {analysis.tokens}")
         print(f"Dependencies: {analysis.dependencies}")
@@ -28,30 +28,29 @@ Example:
     ```
 
     With pandas integration:
-    
+
     ```python
     import pandas as pd
     from openaivec import pandas_ext  # Required for .ai accessor
     from openaivec.task import nlp
-    
+
     df = pd.DataFrame({"text": ["The cat sat on the mat.", "She quickly ran to the store."]})
     df["parsing"] = df["text"].ai.task(nlp.DEPENDENCY_PARSING)
-    
+
     # Extract parsing components
     extracted_df = df.ai.extract("parsing")
     print(extracted_df[["text", "parsing_tokens", "parsing_root_word", "parsing_syntactic_structure"]])
     ```
 
 Attributes:
-    DEPENDENCY_PARSING (PreparedTask): A prepared task instance 
-        configured for dependency parsing with temperature=0.0 and 
-        top_p=1.0 for deterministic output.
+    DEPENDENCY_PARSING (PreparedTask): A prepared task instance configured for dependency
+        parsing. Provide ``temperature=0.0`` and ``top_p=1.0`` when calling the API for
+        deterministic output.
 """
 
-from typing import List
 from pydantic import BaseModel, Field
 
-from ..model import PreparedTask
+from openaivec._model import PreparedTask
 
 __all__ = ["DEPENDENCY_PARSING"]
 
@@ -65,15 +64,15 @@ class DependencyRelation(BaseModel):
 
 
 class DependencyParsing(BaseModel):
-    tokens: List[str] = Field(description="List of tokens in the sentence")
-    dependencies: List[DependencyRelation] = Field(description="Dependency relations between tokens")
+    tokens: list[str] = Field(description="List of tokens in the sentence")
+    dependencies: list[DependencyRelation] = Field(description="Dependency relations between tokens")
     root_word: str = Field(description="Root word of the sentence")
     syntactic_structure: str = Field(description="Tree representation of the syntactic structure")
 
 
 DEPENDENCY_PARSING = PreparedTask(
-    instructions="Parse the syntactic dependencies in the following text. Identify dependency relations between words, determine the root word, and provide a tree representation of the syntactic structure.",
+    instructions="Parse the syntactic dependencies in the following text. Identify dependency "
+    "relations between words, determine the root word, and provide a tree representation of the "
+    "syntactic structure.",
     response_format=DependencyParsing,
-    temperature=0.0,
-    top_p=1.0
-)
+)

openaivec/task/nlp/keyword_extraction.py

@@ -5,23 +5,23 @@ important keywords and phrases from text using OpenAI's language models.
 
 Example:
     Basic usage with BatchResponses:
-    
+
     ```python
     from openai import OpenAI
-    from openaivec.responses import BatchResponses
+    from openaivec import BatchResponses
     from openaivec.task import nlp
-    
+
     client = OpenAI()
     analyzer = BatchResponses.of_task(
         client=client,
-        model_name="gpt-4o-mini",
+        model_name="gpt-4.1-mini",
         task=nlp.KEYWORD_EXTRACTION
     )
-    
-    texts = ["Machine learning is transforming the technology industry.", 
+
+    texts = ["Machine learning is transforming the technology industry.",
              "Climate change affects global weather patterns."]
     analyses = analyzer.parse(texts)
-    
+
     for analysis in analyses:
         print(f"Keywords: {analysis.keywords}")
         print(f"Key phrases: {analysis.keyphrases}")
@@ -29,31 +29,30 @@ Example:
     ```
 
     With pandas integration:
-    
+
     ```python
     import pandas as pd
     from openaivec import pandas_ext  # Required for .ai accessor
     from openaivec.task import nlp
-    
-    df = pd.DataFrame({"text": ["Machine learning is transforming the technology industry.", 
+
+    df = pd.DataFrame({"text": ["Machine learning is transforming the technology industry.",
                                "Climate change affects global weather patterns."]})
     df["keywords"] = df["text"].ai.task(nlp.KEYWORD_EXTRACTION)
-    
+
     # Extract keyword components
     extracted_df = df.ai.extract("keywords")
     print(extracted_df[["text", "keywords_keywords", "keywords_topics", "keywords_summary"]])
     ```
 
 Attributes:
-    KEYWORD_EXTRACTION (PreparedTask): A prepared task instance 
-        configured for keyword extraction with temperature=0.0 and 
-        top_p=1.0 for deterministic output.
+    KEYWORD_EXTRACTION (PreparedTask): A prepared task instance configured for keyword
+        extraction. Provide ``temperature=0.0`` and ``top_p=1.0`` when calling the API
+        for deterministic output.
 """
 
-from typing import List, Optional
 from pydantic import BaseModel, Field
 
-from ..model import PreparedTask
+from openaivec._model import PreparedTask
 
 __all__ = ["KEYWORD_EXTRACTION"]
 
@@ -62,19 +61,18 @@ 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):
-    keywords: List[Keyword] = Field(description="Extracted keywords ranked by importance")
-    keyphrases: List[Keyword] = Field(description="Extracted multi-word phrases ranked by importance")
-    topics: List[str] = Field(description="Identified main topics in the text")
+    keywords: list[Keyword] = Field(description="Extracted keywords ranked by importance")
+    keyphrases: list[Keyword] = Field(description="Extracted multi-word phrases ranked by importance")
+    topics: list[str] = Field(description="Identified main topics in the text")
     summary: str = Field(description="Brief summary of the text content")
 
 
 KEYWORD_EXTRACTION = PreparedTask(
-    instructions="Extract important keywords and phrases from the following text. Rank them by importance, provide frequency counts, identify main topics, and generate a brief summary.",
+    instructions="Extract important keywords and phrases from the following text. Rank them "
+    "by importance, provide frequency counts, identify main topics, and generate a brief summary.",
     response_format=KeywordExtraction,
-    temperature=0.0,
-    top_p=1.0
-)
+)

openaivec/task/nlp/morphological_analysis.py

@@ -1,27 +1,27 @@
 """Morphological analysis task for OpenAI API.
 
 This module provides a predefined task for morphological analysis including
-tokenization, part-of-speech tagging, and lemmatization using OpenAI's 
+tokenization, part-of-speech tagging, and lemmatization using OpenAI's
 language models.
 
 Example:
     Basic usage with BatchResponses:
-    
+
     ```python
     from openai import OpenAI
-    from openaivec.responses import BatchResponses
+    from openaivec import BatchResponses
     from openaivec.task import nlp
-    
+
     client = OpenAI()
     analyzer = BatchResponses.of_task(
         client=client,
-        model_name="gpt-4o-mini",
+        model_name="gpt-4.1-mini",
         task=nlp.MORPHOLOGICAL_ANALYSIS
     )
-    
+
     texts = ["Running quickly", "The cats are sleeping"]
     analyses = analyzer.parse(texts)
-    
+
     for analysis in analyses:
         print(f"Tokens: {analysis.tokens}")
         print(f"POS Tags: {analysis.pos_tags}")
@@ -29,45 +29,45 @@ Example:
     ```
 
     With pandas integration:
-    
+
     ```python
     import pandas as pd
     from openaivec import pandas_ext  # Required for .ai accessor
     from openaivec.task import nlp
-    
+
     df = pd.DataFrame({"text": ["Running quickly", "The cats are sleeping"]})
     df["analysis"] = df["text"].ai.task(nlp.MORPHOLOGICAL_ANALYSIS)
-    
+
     # Extract analysis components
     extracted_df = df.ai.extract("analysis")
     print(extracted_df[["text", "analysis_tokens", "analysis_pos_tags", "analysis_lemmas"]])
     ```
 
 Attributes:
-    MORPHOLOGICAL_ANALYSIS (PreparedTask): A prepared task instance 
-        configured for morphological analysis with temperature=0.0 and 
-        top_p=1.0 for deterministic output.
+    MORPHOLOGICAL_ANALYSIS (PreparedTask): A prepared task instance configured
+        for morphological analysis. Provide ``temperature=0.0`` and ``top_p=1.0`` to
+        API calls for deterministic output.
 """
 
-from typing import List
-from pydantic import BaseModel
-from pydantic import Field
+from pydantic import BaseModel, Field
 
-from ..model import PreparedTask
+from openaivec._model import PreparedTask
 
 __all__ = ["MORPHOLOGICAL_ANALYSIS"]
 
 
 class MorphologicalAnalysis(BaseModel):
-    tokens: List[str] = Field(description="List of tokens in the text")
-    pos_tags: List[str] = Field(description="Part-of-speech tags for each token")
-    lemmas: List[str] = Field(description="Lemmatized form of each token")
-    morphological_features: List[str] = Field(description="Morphological features for each token (e.g., tense, number, case)")
+    tokens: list[str] = Field(description="List of tokens in the text")
+    pos_tags: list[str] = Field(description="Part-of-speech tags for each token")
+    lemmas: list[str] = Field(description="Lemmatized form of each token")
+    morphological_features: list[str] = Field(
+        description="Morphological features for each token (e.g., tense, number, case)"
+    )
 
 
 MORPHOLOGICAL_ANALYSIS = PreparedTask(
-    instructions="Perform morphological analysis on the following text. Break it down into tokens, identify part-of-speech tags, provide lemmatized forms, and extract morphological features for each token.",
+    instructions="Perform morphological analysis on the following text. Break it down into tokens, "
+    "identify part-of-speech tags, provide lemmatized forms, and extract morphological features "
+    "for each token.",
     response_format=MorphologicalAnalysis,
-    temperature=0.0,
-    top_p=1.0
-)
+)