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

openaivec/task/__init__.py

@@ -11,20 +11,20 @@ with openaivec's batch processing capabilities.
 Core NLP tasks for text analysis and processing:
 
 - **Translation**: Multi-language translation with 40+ language support
-- **Sentiment Analysis**: Emotion detection and sentiment scoring  
+- **Sentiment Analysis**: Emotion detection and sentiment scoring
 - **Named Entity Recognition**: Extract people, organizations, locations
 - **Morphological Analysis**: Part-of-speech tagging and lemmatization
 - **Dependency Parsing**: Syntactic structure analysis
 - **Keyword Extraction**: Important term identification
 
-### Customer Support (`customer_support`) 
+### Customer Support (`customer_support`)
 Specialized tasks for customer service operations:
 
 - **Intent Analysis**: Understand customer goals and requirements
 - **Sentiment Analysis**: Customer satisfaction and emotional state
 - **Urgency Analysis**: Priority assessment and response time recommendations
 - **Inquiry Classification**: Automatic categorization and routing
-- **Inquiry Summary**: Comprehensive issue summarization  
+- **Inquiry Summary**: Comprehensive issue summarization
 - **Response Suggestion**: AI-powered response drafting
 
 ## Usage Patterns
@@ -32,7 +32,7 @@ Specialized tasks for customer service operations:
 ### Quick Start with Default Tasks
 ```python
 from openai import OpenAI
-from openaivec.responses import BatchResponses
+from openaivec import BatchResponses
 from openaivec.task import nlp, customer_support
 
 client = OpenAI()
@@ -40,13 +40,13 @@ client = OpenAI()
 # Use pre-configured tasks
 sentiment_analyzer = BatchResponses.of_task(
     client=client,
-    model_name="gpt-4o-mini",
+    model_name="gpt-4.1-mini",
     task=nlp.SENTIMENT_ANALYSIS
 )
 
 intent_analyzer = BatchResponses.of_task(
-    client=client, 
-    model_name="gpt-4o-mini",
+    client=client,
+    model_name="gpt-4.1-mini",
     task=customer_support.INTENT_ANALYSIS
 )
 ```
@@ -60,7 +60,7 @@ custom_urgency = urgency_analysis(
     business_context="SaaS platform support",
     urgency_levels={
         "critical": "Service outages, security breaches",
-        "high": "Login issues, payment failures", 
+        "high": "Login issues, payment failures",
         "medium": "Feature bugs, billing questions",
         "low": "Feature requests, general feedback"
     }
@@ -68,7 +68,7 @@ custom_urgency = urgency_analysis(
 
 analyzer = BatchResponses.of_task(
     client=client,
-    model_name="gpt-4o-mini", 
+    model_name="gpt-4.1-mini",
     task=custom_urgency
 )
 ```
@@ -88,22 +88,24 @@ df["intent"] = df["text"].ai.task(customer_support.INTENT_ANALYSIS)
 results_df = df.ai.extract("sentiment")
 ```
 
-### Spark Integration  
+### Spark Integration
 ```python
-from openaivec.spark import ResponsesUDFBuilder
+from openaivec.spark import task_udf
 
 # Register UDF for large-scale processing
 spark.udf.register(
     "analyze_sentiment",
-    ResponsesUDFBuilder.of_openai(
-        api_key=api_key,
-        model_name="gpt-4o-mini"
-    ).build_from_task(task=nlp.SENTIMENT_ANALYSIS)
+    task_udf(
+        task=nlp.SENTIMENT_ANALYSIS,
+        model_name="gpt-4.1-mini",
+        batch_size=64,
+        max_concurrency=8,
+    ),
 )
 
 # Use in Spark SQL
 df = spark.sql(\"\"\"
-    SELECT text, analyze_sentiment(text) as sentiment 
+    SELECT text, analyze_sentiment(text) as sentiment
     FROM customer_feedback
 \"\"\")
 ```
@@ -117,7 +119,7 @@ All tasks are built using the `PreparedTask` dataclass:
 @dataclass(frozen=True)
 class PreparedTask:
     instructions: str           # Detailed prompt for the LLM
-    response_format: Type[T]    # Pydantic model for structured output
+    response_format: type[ResponseFormat]    # Pydantic model or str for structured/plain output
     temperature: float = 0.0    # Sampling temperature
     top_p: float = 1.0         # Nucleus sampling parameter
 ```
@@ -130,7 +132,7 @@ class PreparedTask:
 
 ### Design Principles
 1. **Consistency**: Uniform API across all task domains
-2. **Configurability**: Customizable parameters for different use cases  
+2. **Configurability**: Customizable parameters for different use cases
 3. **Type Safety**: Strong typing with Pydantic validation
 4. **Scalability**: Optimized for batch processing and large datasets
 5. **Extensibility**: Easy to add new domains and tasks
@@ -164,18 +166,18 @@ src/openaivec/task/finance/
 
 ## Best Practices
 
-1. **Choose Appropriate Models**: 
-   - `gpt-4o-mini`: Fast, cost-effective for most tasks
+1. **Choose Appropriate Models**:
+   - `gpt-4.1-mini`: Fast, cost-effective for most tasks
    - `gpt-4o`: Higher accuracy for complex analysis
-   
-2. **Customize When Needed**: 
+
+2. **Customize When Needed**:
    - Use default tasks for quick prototyping
    - Configure custom tasks for production use
-   
+
 3. **Handle Multilingual Input**:
    - Tasks automatically detect and respond in input language
    - Categorical fields remain in English for system compatibility
-   
+
 4. **Monitor Performance**:
    - Use batch sizes appropriate for your use case
    - Monitor token usage for cost optimization
@@ -183,8 +185,4 @@ src/openaivec/task/finance/
 See individual task modules for detailed documentation and examples.
 """
 
-from .model import PreparedTask
-
-__all__ = [
-    "PreparedTask",
-]
+__all__ = []

openaivec/task/customer_support/__init__.py

@@ -1,32 +1,26 @@
 # Function imports
-from .inquiry_classification import inquiry_classification
-from .urgency_analysis import urgency_analysis
-from .customer_sentiment import customer_sentiment
-from .intent_analysis import intent_analysis
-from .inquiry_summary import inquiry_summary
-from .response_suggestion import response_suggestion
+from .customer_sentiment import CUSTOMER_SENTIMENT, customer_sentiment
 
 # Backward compatibility - constant imports
-from .inquiry_classification import INQUIRY_CLASSIFICATION
-from .urgency_analysis import URGENCY_ANALYSIS
-from .customer_sentiment import CUSTOMER_SENTIMENT
-from .intent_analysis import INTENT_ANALYSIS
-from .inquiry_summary import INQUIRY_SUMMARY
-from .response_suggestion import RESPONSE_SUGGESTION
+from .inquiry_classification import INQUIRY_CLASSIFICATION, inquiry_classification
+from .inquiry_summary import INQUIRY_SUMMARY, inquiry_summary
+from .intent_analysis import INTENT_ANALYSIS, intent_analysis
+from .response_suggestion import RESPONSE_SUGGESTION, response_suggestion
+from .urgency_analysis import URGENCY_ANALYSIS, urgency_analysis
 
 __all__ = [
     # Configurable functions (recommended)
     "inquiry_classification",
-    "urgency_analysis", 
+    "urgency_analysis",
     "customer_sentiment",
     "intent_analysis",
     "inquiry_summary",
     "response_suggestion",
     # Backward compatibility constants
     "INQUIRY_CLASSIFICATION",
-    "URGENCY_ANALYSIS", 
+    "URGENCY_ANALYSIS",
     "CUSTOMER_SENTIMENT",
     "INTENT_ANALYSIS",
     "INQUIRY_SUMMARY",
     "RESPONSE_SUGGESTION",
-]
+]

openaivec/task/customer_support/customer_sentiment.py

@@ -6,26 +6,26 @@ customer experience and support strategy.
 
 Example:
     Basic usage with BatchResponses:
-    
+
     ```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.CUSTOMER_SENTIMENT
     )
-    
+
     inquiries = [
         "I'm really disappointed with your service. This is the third time I've had this issue.",
         "Thank you so much for your help! You've been incredibly patient.",
         "I need to cancel my subscription. It's not working for me."
     ]
     sentiments = analyzer.parse(inquiries)
-    
+
     for sentiment in sentiments:
         print(f"Sentiment: {sentiment.sentiment}")
         print(f"Satisfaction: {sentiment.satisfaction_level}")
@@ -34,68 +34,79 @@ Example:
     ```
 
     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": [
         "I'm really disappointed with your service. This is the third time I've had this issue.",
         "Thank you so much for your help! You've been incredibly patient.",
         "I need to cancel my subscription. It's not working for me."
     ]})
     df["sentiment"] = df["inquiry"].ai.task(customer_support.CUSTOMER_SENTIMENT)
-    
+
     # Extract sentiment components
     extracted_df = df.ai.extract("sentiment")
-    print(extracted_df[["inquiry", "sentiment_satisfaction_level", "sentiment_churn_risk", "sentiment_emotional_state"]])
+    print(extracted_df[[
+        "inquiry", "sentiment_satisfaction_level",
+        "sentiment_churn_risk", "sentiment_emotional_state"
+    ]])
     ```
 
 Attributes:
-    CUSTOMER_SENTIMENT (PreparedTask): A prepared task instance 
-        configured for customer sentiment analysis with temperature=0.0 and 
+    CUSTOMER_SENTIMENT (PreparedTask): A prepared task instance
+        configured for customer sentiment analysis with temperature=0.0 and
         top_p=1.0 for deterministic output.
 """
 
-from typing import List, Literal
+from typing import Literal
+
 from pydantic import BaseModel, Field
 
-from ..model import PreparedTask
+from openaivec._model import PreparedTask
 
 __all__ = ["customer_sentiment"]
 
 
 class CustomerSentiment(BaseModel):
-    sentiment: Literal["positive", "negative", "neutral", "mixed"] = Field(description="Overall sentiment (positive, negative, neutral, mixed)")
-    satisfaction_level: Literal["very_satisfied", "satisfied", "neutral", "dissatisfied", "very_dissatisfied"] = Field(description="Customer satisfaction (very_satisfied, satisfied, neutral, dissatisfied, very_dissatisfied)")
-    emotional_state: Literal["happy", "frustrated", "angry", "disappointed", "confused", "grateful", "worried"] = Field(description="Primary emotional state (happy, frustrated, angry, disappointed, confused, grateful, worried)")
+    sentiment: Literal["positive", "negative", "neutral", "mixed"] = Field(
+        description="Overall sentiment (positive, negative, neutral, mixed)"
+    )
+    satisfaction_level: Literal["very_satisfied", "satisfied", "neutral", "dissatisfied", "very_dissatisfied"] = Field(
+        description="Customer satisfaction (very_satisfied, satisfied, neutral, dissatisfied, very_dissatisfied)"
+    )
+    emotional_state: Literal["happy", "frustrated", "angry", "disappointed", "confused", "grateful", "worried"] = Field(
+        description="Primary emotional state (happy, frustrated, angry, disappointed, confused, grateful, worried)"
+    )
     confidence: float = Field(description="Confidence score for sentiment analysis (0.0-1.0)")
-    churn_risk: Literal["low", "medium", "high", "critical"] = Field(description="Risk of customer churn (low, medium, high, critical)")
+    churn_risk: Literal["low", "medium", "high", "critical"] = Field(
+        description="Risk of customer churn (low, medium, high, critical)"
+    )
     sentiment_intensity: float = Field(description="Intensity of sentiment from 0.0 (mild) to 1.0 (extreme)")
     polarity_score: float = Field(description="Polarity score from -1.0 (very negative) to 1.0 (very positive)")
-    tone_indicators: List[str] = Field(description="Specific words or phrases indicating tone")
-    relationship_status: Literal["new", "loyal", "at_risk", "detractor", "advocate"] = Field(description="Customer relationship status (new, loyal, at_risk, detractor, advocate)")
-    response_approach: Literal["empathetic", "professional", "solution_focused", "escalation_required"] = Field(description="Recommended response approach (empathetic, professional, solution_focused, escalation_required)")
+    tone_indicators: list[str] = Field(description="Specific words or phrases indicating tone")
+    relationship_status: Literal["new", "loyal", "at_risk", "detractor", "advocate"] = Field(
+        description="Customer relationship status (new, loyal, at_risk, detractor, advocate)"
+    )
+    response_approach: Literal["empathetic", "professional", "solution_focused", "escalation_required"] = Field(
+        description="Recommended response approach (empathetic, professional, solution_focused, escalation_required)"
+    )
 
 
-def customer_sentiment(
-    business_context: str = "general customer support",
-    temperature: float = 0.0,
-    top_p: float = 1.0
-) -> PreparedTask:
+def customer_sentiment(business_context: str = "general customer support") -> PreparedTask:
     """Create a configurable customer sentiment analysis task.
-    
+
     Args:
-        business_context: Business context for sentiment analysis.
-        temperature: Sampling temperature (0.0-1.0).
-        top_p: Nucleus sampling parameter (0.0-1.0).
-        
+        business_context (str): Business context for sentiment analysis.
+
     Returns:
         PreparedTask configured for customer sentiment analysis.
     """
-    
-    instructions = f"""Analyze customer sentiment in the context of support interactions, focusing on satisfaction, emotional state, and business implications.
+
+    instructions = f"""Analyze customer sentiment in the context of support interactions, focusing on
+satisfaction, emotional state, and business implications.
 
 Business Context: {business_context}
 
@@ -146,17 +157,16 @@ Analyze tone indicators like:
 - Urgency: "urgent", "immediately", "ASAP", "critical"
 - Threat: "cancel", "switch", "competitor", "lawyer", "report"
 
-IMPORTANT: Provide analysis responses in the same language as the input text, except for the predefined categorical fields (sentiment, satisfaction_level, emotional_state, churn_risk, relationship_status, response_approach) which must use the exact English values specified above. For example, if the input is in Spanish, provide tone_indicators in Spanish, but use English values like "positive" for sentiment.
+IMPORTANT: Provide analysis responses in the same language as the input text, except for the
+predefined categorical fields (sentiment, satisfaction_level, emotional_state, churn_risk,
+relationship_status, response_approach) which must use the exact English values specified above.
+For example, if the input is in Spanish, provide tone_indicators in Spanish, but use English
+values like "positive" for sentiment.
 
 Provide comprehensive sentiment analysis with business context and recommended response strategy."""
 
-    return PreparedTask(
-        instructions=instructions,
-        response_format=CustomerSentiment,
-        temperature=temperature,
-        top_p=top_p
-    )
+    return PreparedTask(instructions=instructions, response_format=CustomerSentiment)
 
 
 # Backward compatibility - default configuration
-CUSTOMER_SENTIMENT = customer_sentiment()
+CUSTOMER_SENTIMENT = customer_sentiment()

openaivec/task/customer_support/inquiry_classification.py

@@ -5,26 +5,26 @@ different categories to help route them to the appropriate support team.
 
 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()
     classifier = BatchResponses.of_task(
         client=client,
-        model_name="gpt-4o-mini",
+        model_name="gpt-4.1-mini",
         task=customer_support.inquiry_classification()
     )
-    
+
     inquiries = [
         "I can't log into my account",
         "When will my order arrive?",
         "I want to cancel my subscription"
     ]
     classifications = classifier.parse(inquiries)
-    
+
     for classification in classifications:
         print(f"Category: {classification.category}")
         print(f"Subcategory: {classification.subcategory}")
@@ -33,10 +33,10 @@ Example:
     ```
 
     Customized for e-commerce:
-    
+
     ```python
     from openaivec.task import customer_support
-    
+
     # E-commerce specific categories
     ecommerce_categories = {
         "order_management": ["order_status", "order_cancellation", "order_modification", "returns"],
@@ -46,53 +46,57 @@ Example:
         "account": ["login_issues", "account_settings", "profile_updates", "password_reset"],
         "general": ["complaints", "compliments", "feedback", "other"]
     }
-    
+
     ecommerce_routing = {
         "order_management": "order_team",
-        "payment": "billing_team", 
+        "payment": "billing_team",
         "product": "product_team",
         "shipping": "logistics_team",
         "account": "account_support",
         "general": "general_support"
     }
-    
+
     task = customer_support.inquiry_classification(
         categories=ecommerce_categories,
         routing_rules=ecommerce_routing,
         business_context="e-commerce platform"
     )
-    
+
     classifier = 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": [
         "I can't log into my account",
         "When will my order arrive?",
         "I want to cancel my subscription"
     ]})
     df["classification"] = df["inquiry"].ai.task(customer_support.inquiry_classification())
-    
+
     # Extract classification components
     extracted_df = df.ai.extract("classification")
-    print(extracted_df[["inquiry", "classification_category", "classification_subcategory", "classification_confidence"]])
+    print(extracted_df[[
+        "inquiry", "classification_category",
+        "classification_subcategory", "classification_confidence"
+    ]])
     ```
 """
 
-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__ = ["inquiry_classification"]
 
@@ -102,92 +106,115 @@ class InquiryClassification(BaseModel):
     subcategory: str = Field(description="Specific subcategory within the primary category")
     confidence: float = Field(description="Confidence score for classification (0.0-1.0)")
     routing: str = Field(description="Recommended routing destination")
-    keywords: List[str] = Field(description="Key terms that influenced the classification")
-    priority: Literal["low", "medium", "high", "urgent"] = Field(description="Suggested priority level (low, medium, high, urgent)")
+    keywords: list[str] = Field(description="Key terms that influenced the classification")
+    priority: Literal["low", "medium", "high", "urgent"] = Field(
+        description="Suggested priority level (low, medium, high, urgent)"
+    )
     business_context_match: bool = Field(description="Whether the inquiry matches the business context")
 
 
 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,
-    temperature: float = 0.0,
-    top_p: float = 1.0
+    custom_keywords: Dict[str, list[str]] | None = None,
 ) -> PreparedTask:
     """Create a configurable inquiry classification task.
-    
+
     Args:
-        categories: 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: 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: 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: Description of the business context to help with classification.
-        custom_keywords: Dictionary mapping categories to relevant keywords.
-        temperature: Sampling temperature (0.0-1.0).
-        top_p: Nucleus sampling parameter (0.0-1.0).
-        
+        business_context (str): Description of the business context to help with classification.
+        custom_keywords (dict[str, list[str]] | None): Dictionary mapping categories to relevant keywords.
+
     Returns:
         PreparedTask configured for inquiry classification.
     """
-    
+
     # Default categories
     if categories is None:
         categories = {
-            "technical": ["login_issues", "password_reset", "app_crashes", "connectivity_problems", "feature_not_working"],
-            "billing": ["payment_failed", "invoice_questions", "refund_request", "pricing_inquiry", "subscription_changes"],
-            "product": ["feature_request", "product_information", "compatibility_questions", "how_to_use", "bug_reports"],
-            "shipping": ["delivery_status", "shipping_address", "delivery_issues", "tracking_number", "expedited_shipping"],
+            "technical": [
+                "login_issues",
+                "password_reset",
+                "app_crashes",
+                "connectivity_problems",
+                "feature_not_working",
+            ],
+            "billing": [
+                "payment_failed",
+                "invoice_questions",
+                "refund_request",
+                "pricing_inquiry",
+                "subscription_changes",
+            ],
+            "product": [
+                "feature_request",
+                "product_information",
+                "compatibility_questions",
+                "how_to_use",
+                "bug_reports",
+            ],
+            "shipping": [
+                "delivery_status",
+                "shipping_address",
+                "delivery_issues",
+                "tracking_number",
+                "expedited_shipping",
+            ],
             "account": ["account_creation", "profile_updates", "account_deletion", "data_export", "privacy_settings"],
-            "general": ["compliments", "complaints", "feedback", "partnership_inquiry", "other"]
+            "general": ["compliments", "complaints", "feedback", "partnership_inquiry", "other"],
         }
-    
+
     # Default routing rules
     if routing_rules is None:
         routing_rules = {
             "technical": "tech_support",
-            "billing": "billing_team", 
+            "billing": "billing_team",
             "product": "product_team",
             "shipping": "shipping_team",
             "account": "account_management",
-            "general": "general_support"
+            "general": "general_support",
         }
-    
+
     # Default priority rules
     if priority_rules is None:
         priority_rules = {
             "urgent": "urgent, emergency, critical, down, outage, security, breach, immediate",
             "high": "login, password, payment, billing, delivery, problem, issue, error, bug",
             "medium": "feature, request, question, how, help, support, feedback",
-            "low": "information, compliment, thank, suggestion, general, other"
+            "low": "information, compliment, thank, suggestion, general, other",
         }
-    
+
     # Build categories section
     categories_text = "Categories and subcategories:\n"
     for category, subcategories in categories.items():
         categories_text += f"- {category}: {', '.join(subcategories)}\n"
-    
+
     # Build routing section
     routing_text = "Routing options:\n"
     for category, routing in routing_rules.items():
         routing_text += f"- {routing}: {category.replace('_', ' ').title()} issues\n"
-    
+
     # Build priority section
     priority_text = "Priority levels:\n"
     for priority, keywords in priority_rules.items():
         priority_text += f"- {priority}: {keywords}\n"
-    
+
     # Build custom keywords section
     keywords_text = ""
     if custom_keywords:
         keywords_text = "\nCustom keywords for classification:\n"
         for category, keywords in custom_keywords.items():
             keywords_text += f"- {category}: {', '.join(keywords)}\n"
-    
-    instructions = f"""Classify the customer inquiry into the appropriate category and subcategory based on the configured categories and business context.
+
+    instructions = f"""Classify the customer inquiry into the appropriate category and subcategory
+based on the configured categories and business context.
 
 Business Context: {business_context}
 
@@ -216,17 +243,15 @@ Consider:
 - Business impact
 - Customer type indicators
 
-IMPORTANT: Provide analysis responses in the same language as the input text, except for the predefined categorical fields (priority) which must use the exact English values specified above. Category, subcategory, routing, and keywords should reflect the content and can be in the input language where appropriate, but priority must use English values like "high".
+IMPORTANT: Provide analysis responses in the same language as the input text, except for the
+predefined categorical fields (priority) which must use the exact English values specified above.
+Category, subcategory, routing, and keywords should reflect the content and can be in the input
+language where appropriate, but priority must use English values like "high".
 
 Provide accurate classification with detailed reasoning."""
 
-    return PreparedTask(
-        instructions=instructions,
-        response_format=InquiryClassification,
-        temperature=temperature,
-        top_p=top_p
-    )
+    return PreparedTask(instructions=instructions, response_format=InquiryClassification)
 
 
 # Backward compatibility - default configuration
-INQUIRY_CLASSIFICATION = inquiry_classification()
+INQUIRY_CLASSIFICATION = inquiry_classification()