Factory Pattern

Creational pattern for OCP-compliant object creation

Overview

Category

Creational Design Pattern

Purpose

Encapsulate object creation logic

---

Problem Statement

The Challenge

We need to create different classifier and strategy objects based on runtime configuration:

1. Encapsulate creation logic: Complex initialization
2. OCP Compliance: Add new types without modifying factory code
3. Centralized creation: Single point of change

OCP Demonstration

Adding a new classifier requires ONLY:

# Step 1: Create factory function
def _create_bert_classifier() -> IntentClassifier:
    return BertClassifier(model="bert-base-turkish")

# Step 2: Add to registry (NO changes to get_classifier!)
CLASSIFIER_MAP["bert"] = _create_bert_classifier

✅ Open for extension, closed for modification

---

Solution: Dictionary Map Factory

Flowchart

Classifier Factory

CLASSIFIER_MAP: dict[str, Callable[[], IntentClassifier]] = {
    "ollama": _create_ollama_classifier,
    "fuzzy": _create_fuzzy_classifier,
    "hybrid": _create_hybrid_classifier,
}

def get_classifier() -> IntentClassifier:
    method = settings.CLASSIFICATION_METHOD
    factory_fn = CLASSIFIER_MAP.get(method, _create_fuzzy_classifier)
    return factory_fn()

Strategy Factory

STRATEGY_MAP: dict[str, type[ContextStrategy]] = {
    "dining": DiningStrategy,
    "announcement": AnnouncementStrategy,
    "general": GeneralStrategy,
}

def get_context_strategy(intent: str) -> ContextStrategy:
    StrategyClass = STRATEGY_MAP.get(intent, GeneralStrategy)
    return StrategyClass()  # Fresh instance every call

File Locations

Factory	File
get_classifier()	llm_engine/classifier.py
get_context_strategy()	strategies/context_strategies.py

Factory vs Singleton: Factory creates new instances on each call. This prevents state leakage between requests.

---

Benefits

OCP Compliance

Add new types by adding to registry only

Encapsulation

Complex creation logic hidden from client

Centralized

Single point of change for object creation

Configurable

Runtime selection via environment variables