aishastr.live

Agentic Architecture Pattern: Feature Toggle

Written by

admin

in


    """
Pattern 275: Feature Toggle

Purpose: Dynamic feature management with runtime control and gradual rollout
"""

from typing import Dict, Any, List, Optional, Set, Callable
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
from collections import defaultdict


class ToggleState(Enum):
    """State of feature toggle."""
    DISABLED = "disabled"
    ENABLED_FOR_TESTING = "enabled_for_testing"
    ENABLED_FOR_PERCENTAGE = "enabled_for_percentage"
    ENABLED_FOR_USERS = "enabled_for_users"
    FULLY_ENABLED = "fully_enabled"
    DEPRECATED = "deprecated"


class RolloutStrategy(Enum):
    """Strategy for feature rollout."""
    ALL_AT_ONCE = "all_at_once"
    PERCENTAGE_BASED = "percentage_based"
    USER_TARGETED = "user_targeted"
    RING_BASED = "ring_based"  # Canary, beta, production rings


@dataclass
class Feature:
    """Represents a feature toggle."""
    name: str
    description: str
    state: ToggleState
    created_at: datetime = field(default_factory=datetime.now)
    enabled_percentage: float = 0.0  # 0-100
    enabled_users: Set[str] = field(default_factory=set)
    enabled_rings: Set[str] = field(default_factory=set)
    metadata: Dict[str, Any] = field(default_factory=dict)
    last_modified: datetime = field(default_factory=datetime.now)


@dataclass
class ToggleDecision:
    """Result of feature toggle evaluation."""
    feature_name: str
    enabled: bool
    reason: str
    user_id: Optional[str] = None
    ring: Optional[str] = None
    timestamp: datetime = field(default_factory=datetime.now)


@dataclass
class ToggleMetrics:
    """Metrics for feature toggle usage."""
    total_evaluations: int = 0
    enabled_count: int = 0
    disabled_count: int = 0
    unique_users: Set[str] = field(default_factory=set)
    evaluations_by_user: Dict[str, int] = field(default_factory=lambda: defaultdict(int))


class FeatureToggle:
    """
    Implements feature toggle pattern.
    
    Features:
    - Runtime enable/disable
    - Percentage-based rollout
    - User-targeted features
    - Ring-based deployment
    - A/B testing support
    - Feature dependencies
    - Metrics collection
    """
    
    def __init__(self):
        self.features: Dict[str, Feature] = {}
        self.metrics: Dict[str, ToggleMetrics] = defaultdict(ToggleMetrics)
        self.decisions: List[ToggleDecision] = []
        self.dependencies: Dict[str, List[str]] = {}  # feature -> required features
        
        # Statistics
        self.statistics = {
            "total_features": 0,
            "enabled_features": 0,
            "disabled_features": 0,
            "total_evaluations": 0
        }
    
    def create_feature(
        self,
        name: str,
        description: str,
        state: ToggleState = ToggleState.DISABLED,
        metadata: Optional[Dict[str, Any]] = None
    ) -> Dict[str, Any]:
        """
        Create a new feature toggle.
        
        Args:
            name: Feature name
            description: Feature description
            state: Initial state
            metadata: Additional metadata
            
        Returns:
            Status of feature creation
        """
        if name in self.features:
            return {
                "success": False,
                "message": f"Feature '{name}' already exists"
            }
        
        feature = Feature(
            name=name,
            description=description,
            state=state,
            metadata=metadata or {}
        )
        
        self.features[name] = feature
        self.statistics["total_features"] += 1
        
        if state != ToggleState.DISABLED:
            self.statistics["enabled_features"] += 1
        else:
            self.statistics["disabled_features"] += 1
        
        return {
            "success": True,
            "feature": name,
            "state": state.value,
            "message": f"Feature '{name}' created successfully"
        }
    
    def enable_feature(
        self,
        name: str,
        strategy: RolloutStrategy = RolloutStrategy.ALL_AT_ONCE,
        percentage: float = 100.0,
        users: Optional[List[str]] = None,
        rings: Optional[List[str]] = None
    ) -> Dict[str, Any]:
        """
        Enable a feature with specified strategy.
        
        Args:
            name: Feature name
            strategy: Rollout strategy
            percentage: Percentage of users (0-100)
            users: Specific users to enable for
            rings: Specific rings to enable in
            
        Returns:
            Status of feature enable
        """
        if name not in self.features:
            return {
                "success": False,
                "message": f"Feature '{name}' not found"
            }
        
        feature = self.features[name]
        
        # Check dependencies
        if name in self.dependencies:
            for dep in self.dependencies[name]:
                if dep not in self.features or self.features[dep].state == ToggleState.DISABLED:
                    return {
                        "success": False,
                        "message": f"Cannot enable '{name}': dependency '{dep}' is not enabled"
                    }
        
        old_state = feature.state
        
        if strategy == RolloutStrategy.ALL_AT_ONCE:
            feature.state = ToggleState.FULLY_ENABLED
            feature.enabled_percentage = 100.0
        
        elif strategy == RolloutStrategy.PERCENTAGE_BASED:
            feature.state = ToggleState.ENABLED_FOR_PERCENTAGE
            feature.enabled_percentage = min(100.0, max(0.0, percentage))
        
        elif strategy == RolloutStrategy.USER_TARGETED:
            feature.state = ToggleState.ENABLED_FOR_USERS
            if users:
                feature.enabled_users.update(users)
        
        elif strategy == RolloutStrategy.RING_BASED:
            feature.state = ToggleState.ENABLED_FOR_PERCENTAGE  # Start with ring-based
            if rings:
                feature.enabled_rings.update(rings)
        
        feature.last_modified = datetime.now()
        
        if old_state == ToggleState.DISABLED:
            self.statistics["enabled_features"] += 1
            self.statistics["disabled_features"] -= 1
        
        return {
            "success": True,
            "feature": name,
            "strategy": strategy.value,
            "state": feature.state.value,
            "percentage": feature.enabled_percentage,
            "message": f"Feature '{name}' enabled with {strategy.value} strategy"
        }
    
    def disable_feature(self, name: str) -> Dict[str, Any]:
        """
        Disable a feature.
        
        Args:
            name: Feature name
            
        Returns:
            Status of feature disable
        """
        if name not in self.features:
            return {
                "success": False,
                "message": f"Feature '{name}' not found"
            }
        
        feature = self.features[name]
        old_state = feature.state
        
        feature.state = ToggleState.DISABLED
        feature.enabled_percentage = 0.0
        feature.enabled_users.clear()
        feature.enabled_rings.clear()
        feature.last_modified = datetime.now()
        
        if old_state != ToggleState.DISABLED:
            self.statistics["enabled_features"] -= 1
            self.statistics["disabled_features"] += 1
        
        return {
            "success": True,
            "feature": name,
            "message": f"Feature '{name}' disabled"
        }
    
    def is_enabled(
        self,
        name: str,
        user_id: Optional[str] = None,
        ring: Optional[str] = None,
        context: Optional[Dict[str, Any]] = None
    ) -> bool:
        """
        Check if feature is enabled for given context.
        
        Args:
            name: Feature name
            user_id: User identifier
            ring: Deployment ring
            context: Additional context
            
        Returns:
            True if feature is enabled
        """
        decision = self.evaluate(name, user_id, ring, context)
        return decision["enabled"]
    
    def evaluate(
        self,
        name: str,
        user_id: Optional[str] = None,
        ring: Optional[str] = None,
        context: Optional[Dict[str, Any]] = None
    ) -> Dict[str, Any]:
        """
        Evaluate if feature should be enabled with detailed reasoning.
        
        Args:
            name: Feature name
            user_id: User identifier
            ring: Deployment ring
            context: Additional context
            
        Returns:
            Evaluation decision with reasoning
        """
        self.statistics["total_evaluations"] += 1
        
        if name not in self.features:
            decision = ToggleDecision(
                feature_name=name,
                enabled=False,
                reason="Feature not found",
                user_id=user_id,
                ring=ring
            )
            self.decisions.append(decision)
            return {
                "enabled": False,
                "reason": "Feature not found",
                "feature": name
            }
        
        feature = self.features[name]
        metrics = self.metrics[name]
        metrics.total_evaluations += 1
        
        if user_id:
            metrics.unique_users.add(user_id)
            metrics.evaluations_by_user[user_id] += 1
        
        enabled = False
        reason = ""
        
        # Check feature state
        if feature.state == ToggleState.DISABLED:
            enabled = False
            reason = "Feature is disabled"
        
        elif feature.state == ToggleState.FULLY_ENABLED:
            enabled = True
            reason = "Feature is fully enabled"
        
        elif feature.state == ToggleState.ENABLED_FOR_TESTING:
            # Only enabled in test mode
            enabled = context and context.get("test_mode", False)
            reason = "Feature enabled for testing only" if enabled else "Feature only available in test mode"
        
        elif feature.state == ToggleState.ENABLED_FOR_USERS:
            if user_id and user_id in feature.enabled_users:
                enabled = True
                reason = f"Feature enabled for user '{user_id}'"
            else:
                enabled = False
                reason = "User not in enabled list"
        
        elif feature.state == ToggleState.ENABLED_FOR_PERCENTAGE:
            # Check ring first
            if feature.enabled_rings and ring:
                if ring in feature.enabled_rings:
                    enabled = True
                    reason = f"Feature enabled for ring '{ring}'"
                else:
                    enabled = False
                    reason = f"Ring '{ring}' not enabled"
            else:
                # Percentage-based rollout
                if user_id:
                    # Consistent hashing for user
                    user_hash = hash(f"{name}:{user_id}") % 100
                    enabled = user_hash < feature.enabled_percentage
                    reason = f"User in {feature.enabled_percentage}% rollout" if enabled else f"User not in {feature.enabled_percentage}% rollout"
                else:
                    # No user ID, use random
                    import random
                    enabled = random.random() * 100  Dict[str, Any]:
        """Update rollout percentage for a feature."""
        if name not in self.features:
            return {
                "success": False,
                "message": f"Feature '{name}' not found"
            }
        
        feature = self.features[name]
        feature.enabled_percentage = min(100.0, max(0.0, percentage))
        feature.last_modified = datetime.now()
        
        return {
            "success": True,
            "feature": name,
            "percentage": feature.enabled_percentage,
            "message": f"Updated '{name}' to {feature.enabled_percentage}% rollout"
        }
    
    def add_dependency(self, feature: str, requires: str) -> Dict[str, Any]:
        """Add dependency between features."""
        if feature not in self.features:
            return {
                "success": False,
                "message": f"Feature '{feature}' not found"
            }
        
        if requires not in self.features:
            return {
                "success": False,
                "message": f"Required feature '{requires}' not found"
            }
        
        if feature not in self.dependencies:
            self.dependencies[feature] = []
        
        if requires not in self.dependencies[feature]:
            self.dependencies[feature].append(requires)
        
        return {
            "success": True,
            "message": f"Feature '{feature}' now requires '{requires}'"
        }
    
    def get_feature_status(self, name: str) -> Dict[str, Any]:
        """Get status of a specific feature."""
        if name not in self.features:
            return {
                "success": False,
                "message": f"Feature '{name}' not found"
            }
        
        feature = self.features[name]
        metrics = self.metrics[name]
        
        return {
            "success": True,
            "feature": {
                "name": feature.name,
                "description": feature.description,
                "state": feature.state.value,
                "enabled_percentage": feature.enabled_percentage,
                "enabled_users_count": len(feature.enabled_users),
                "enabled_rings": list(feature.enabled_rings),
                "created_at": feature.created_at.isoformat(),
                "last_modified": feature.last_modified.isoformat()
            },
            "metrics": {
                "total_evaluations": metrics.total_evaluations,
                "enabled_count": metrics.enabled_count,
                "disabled_count": metrics.disabled_count,
                "unique_users": len(metrics.unique_users),
                "enable_rate": (metrics.enabled_count / metrics.total_evaluations * 100) if metrics.total_evaluations > 0 else 0
            },
            "dependencies": self.dependencies.get(name, [])
        }
    
    def list_features(self) -> Dict[str, Any]:
        """List all features."""
        features_list = []
        for name, feature in self.features.items():
            features_list.append({
                "name": name,
                "description": feature.description,
                "state": feature.state.value,
                "enabled_percentage": feature.enabled_percentage
            })
        
        return {
            "total": len(features_list),
            "features": features_list
        }
    
    def get_statistics(self) -> Dict[str, Any]:
        """Get toggle statistics."""
        return {
            "total_features": self.statistics["total_features"],
            "enabled_features": self.statistics["enabled_features"],
            "disabled_features": self.statistics["disabled_features"],
            "total_evaluations": self.statistics["total_evaluations"],
            "total_decisions": len(self.decisions)
        }


class FeatureTogglePattern:
    """
    Coordinator for feature toggle management.
    
    Manages feature flags with various rollout strategies.
    """
    
    def __init__(self):
        self.toggle = FeatureToggle()
    
    def create_feature(
        self,
        name: str,
        description: str,
        state: ToggleState = ToggleState.DISABLED
    ) -> Dict[str, Any]:
        """Create a new feature."""
        return self.toggle.create_feature(name, description, state)
    
    def enable_feature(
        self,
        name: str,
        strategy: RolloutStrategy = RolloutStrategy.ALL_AT_ONCE,
        **kwargs
    ) -> Dict[str, Any]:
        """Enable a feature."""
        return self.toggle.enable_feature(name, strategy, **kwargs)
    
    def disable_feature(self, name: str) -> Dict[str, Any]:
        """Disable a feature."""
        return self.toggle.disable_feature(name)
    
    def is_enabled(self, name: str, **kwargs) -> bool:
        """Check if feature is enabled."""
        return self.toggle.is_enabled(name, **kwargs)
    
    def evaluate(self, name: str, **kwargs) -> Dict[str, Any]:
        """Evaluate feature toggle."""
        return self.toggle.evaluate(name, **kwargs)
    
    def get_feature_status(self, name: str) -> Dict[str, Any]:
        """Get feature status."""
        return self.toggle.get_feature_status(name)
    
    def list_features(self) -> Dict[str, Any]:
        """List all features."""
        return self.toggle.list_features()
    
    def get_statistics(self) -> Dict[str, Any]:
        """Get statistics."""
        return self.toggle.get_statistics()


# Example usage
if __name__ == "__main__":
    print("=== Feature Toggle Demo ===\n")
    
    # Create feature toggle manager
    pattern = FeatureTogglePattern()
    
    print("1. Creating features...")
    pattern.create_feature("new_ui", "New user interface", ToggleState.DISABLED)
    pattern.create_feature("advanced_search", "Advanced search functionality", ToggleState.DISABLED)
    pattern.create_feature("dark_mode", "Dark mode theme", ToggleState.DISABLED)
    
    features = pattern.list_features()
    print(f"  Total features: {features['total']}")
    for feature in features['features']:
        print(f"    - {feature['name']}: {feature['state']}")
    
    # Enable with different strategies
    print("\n2. Enabling features with different strategies...")
    
    # All at once
    result = pattern.enable_feature("dark_mode", RolloutStrategy.ALL_AT_ONCE)
    print(f"  {result['message']}")
    
    # Percentage-based rollout
    result = pattern.enable_feature("new_ui", RolloutStrategy.PERCENTAGE_BASED, percentage=25.0)
    print(f"  {result['message']}")
    
    # User-targeted
    result = pattern.enable_feature("advanced_search", RolloutStrategy.USER_TARGETED, users=["user1", "user2", "user3"])
    print(f"  {result['message']}")
    
    # Test evaluations
    print("\n3. Evaluating features for different users...")
    
    # Dark mode (fully enabled)
    eval_result = pattern.evaluate("dark_mode", user_id="user1")
    print(f"  dark_mode for user1: {eval_result['enabled']} ({eval_result['reason']})")
    
    # New UI (25% rollout)
    for user_id in ["user1", "user2", "user3", "user4"]:
        eval_result = pattern.evaluate("new_ui", user_id=user_id)
        print(f"  new_ui for {user_id}: {eval_result['enabled']} ({eval_result['reason']})")
    
    # Advanced search (user-targeted)
    for user_id in ["user1", "user4"]:
        eval_result = pattern.evaluate("advanced_search", user_id=user_id)
        print(f"  advanced_search for {user_id}: {eval_result['enabled']} ({eval_result['reason']})")
    
    # Increase rollout percentage
    print("\n4. Increasing new_ui rollout to 50%...")
    result = pattern.toggle.update_percentage("new_ui", 50.0)
    print(f"  {result['message']}")
    
    # Feature status
    print("\n5. Feature status:")
    status = pattern.get_feature_status("new_ui")
    if status['success']:
        feature_info = status['feature']
        metrics_info = status['metrics']
        print(f"  Feature: {feature_info['name']}")
        print(f"  State: {feature_info['state']}")
        print(f"  Rollout: {feature_info['enabled_percentage']}%")
        print(f"  Total evaluations: {metrics_info['total_evaluations']}")
        print(f"  Enable rate: {metrics_info['enable_rate']:.1f}%")
        print(f"  Unique users: {metrics_info['unique_users']}")
    
    # Statistics
    print("\n6. Overall statistics:")
    stats = pattern.get_statistics()
    print(f"  Total features: {stats['total_features']}")
    print(f"  Enabled: {stats['enabled_features']}")
    print(f"  Disabled: {stats['disabled_features']}")
    print(f"  Total evaluations: {stats['total_evaluations']}")
    
    print("\nāœ“ Comprehensive feature toggle with dynamic control complete!")

Agentic Architecture Pattern: Feature Toggle

Pattern 275: 275 Feature Toggle – Line-by-Line Explanation

Overview

Pattern 275: Feature Toggle

Purpose: Dynamic feature management with runtime control and gradual rollout

Code Structure Analysis

File Information

  • Pattern Number: 275
  • Pattern Name: 275 Feature Toggle
  • File Path: patterns\deployment\275_feature_toggle.py
  • Total Lines: 623

Detailed Code Explanation

Module Docstring

"""
Pattern 275: Feature Toggle

Purpose: Dynamic feature management with runtime control and gradual rollout
"""

Explanation: This module docstring describes the purpose and key features of the 275 Feature Toggle pattern.

Imports Section

from typing import Dict, Any, List, Optional, Set, Callable
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
from collections import defaultdict
                    import random  # First 20 imports shown

Explanation: The module imports necessary dependencies: – from typing import Dict, Any, List, Optional, Set, Callable: Type hints for better code documentation – from dataclasses import dataclass, field: Data class decorators for clean data structures – from datetime import datetime: Date and time utilities – from enum import Enum: Enumeration support for fixed sets of values

Enumerations

ToggleState (Line 14)

class ToggleState(Enum):
    DISABLED
    ENABLED_FOR_TESTING
    ENABLED_FOR_PERCENTAGE
    ENABLED_FOR_USERS
    FULLY_ENABLED
    DEPRECATED

Purpose: State of feature toggle.

Values: – DISABLED: Represents disabled – ENABLED_FOR_TESTING: Represents enabled for testing – ENABLED_FOR_PERCENTAGE: Represents enabled for percentage – ENABLED_FOR_USERS: Represents enabled for users – FULLY_ENABLED: Represents fully enabled – DEPRECATED: Represents deprecated

RolloutStrategy (Line 24)

class RolloutStrategy(Enum):
    ALL_AT_ONCE
    PERCENTAGE_BASED
    USER_TARGETED
    RING_BASED

Purpose: Strategy for feature rollout.

Values: – ALL_AT_ONCE: Represents all at once – PERCENTAGE_BASED: Represents percentage based – USER_TARGETED: Represents user targeted – RING_BASED: Represents ring based

Classes

ToggleState (Line 14)

Description: State of feature toggle.

RolloutStrategy (Line 24)

Description: Strategy for feature rollout.

Feature (Line 33)

Description: Represents a feature toggle.

ToggleDecision (Line 47)

Description: Result of feature toggle evaluation.

ToggleMetrics (Line 58)

Description: Metrics for feature toggle usage.

FeatureToggle (Line 67)

Description: Implements feature toggle pattern.

Features: – Runtime enable/disable – Percentage-based rollout – User-targeted features – Ring-based deployment – A/B testing support – Feature dependencies – Metrics collection

Methods:

__init__ (Line 81)
def __init__(self):
    """No method docstring."""

Purpose: No method docstring.

Parameters: – self: Instance reference

create_feature (Line 95)
def create_feature(self, name, description, state, metadata):
    """Create a new feature toggle.

Args:
    name: Feature name
    description: Feature description
    state: Initial state
    metadata: Additional metadata

Returns:
    Status of feature creation"""

Purpose: Create a new feature toggle.

Args: name: Feature name description: Feature description state: Initial state metadata: Additional metadata

Returns: Status of feature creation

Parameters: – self: Instance reference – name: Identifier or label – description: Parameter for description – state: Current workflow state – metadata: Parameter for metadata

enable_feature (Line 142)
def enable_feature(self, name, strategy, percentage, users, rings):
    """Enable a feature with specified strategy.

Args:
    name: Feature name
    strategy: Rollout strategy
    percentage: Percentage of users (0-100)
    users: Specific users to enable for
    rings: Specific rings to enable in

Returns:
    Status of feature enable"""

Purpose: Enable a feature with specified strategy.

Args: name: Feature name strategy: Rollout strategy percentage: Percentage of users (0-100) users: Specific users to enable for rings: Specific rings to enable in

Returns: Status of feature enable

Parameters: – self: Instance reference – name: Identifier or label – strategy: Parameter for strategy – percentage: Parameter for percentage – users: Parameter for users – rings: Parameter for rings

disable_feature (Line 215)
def disable_feature(self, name):
    """Disable a feature.

Args:
    name: Feature name

Returns:
    Status of feature disable"""

Purpose: Disable a feature.

Args: name: Feature name

Returns: Status of feature disable

Parameters: – self: Instance reference – name: Identifier or label

is_enabled (Line 250)
def is_enabled(self, name, user_id, ring, context):
    """Check if feature is enabled for given context.

Args:
    name: Feature name
    user_id: User identifier
    ring: Deployment ring
    context: Additional context

Returns:
    True if feature is enabled"""

Purpose: Check if feature is enabled for given context.

Args: name: Feature name user_id: User identifier ring: Deployment ring context: Additional context

Returns: True if feature is enabled

Parameters: – self: Instance reference – name: Identifier or label – user_id: Parameter for user_id – ring: Parameter for ring – context: Parameter for context

evaluate (Line 272)
def evaluate(self, name, user_id, ring, context):
    """Evaluate if feature should be enabled with detailed reasoning.

Args:
    name: Feature name
    user_id: User identifier
    ring: Deployment ring
    context: Additional context

Returns:
    Evaluation decision with reasoning"""

Purpose: Evaluate if feature should be enabled with detailed reasoning.

Args: name: Feature name user_id: User identifier ring: Deployment ring context: Additional context

Returns: Evaluation decision with reasoning

Parameters: – self: Instance reference – name: Identifier or label – user_id: Parameter for user_id – ring: Parameter for ring – context: Parameter for context

update_percentage (Line 390)
def update_percentage(self, name, percentage):
    """Update rollout percentage for a feature."""

Purpose: Update rollout percentage for a feature.

Parameters: – self: Instance reference – name: Identifier or label – percentage: Parameter for percentage

add_dependency (Line 409)
def add_dependency(self, feature, requires):
    """Add dependency between features."""

Purpose: Add dependency between features.

Parameters: – self: Instance reference – feature: Parameter for feature – requires: Parameter for requires

get_feature_status (Line 434)
def get_feature_status(self, name):
    """Get status of a specific feature."""

Purpose: Get status of a specific feature.

Parameters: – self: Instance reference – name: Identifier or label

list_features (Line 467)
def list_features(self):
    """List all features."""

Purpose: List all features.

Parameters: – self: Instance reference

get_statistics (Line 483)
def get_statistics(self):
    """Get toggle statistics."""

Purpose: Get toggle statistics.

Parameters: – self: Instance reference

FeatureTogglePattern (Line 494)

Description: Coordinator for feature toggle management.

Manages feature flags with various rollout strategies.

Methods:

__init__ (Line 501)
def __init__(self):
    """No method docstring."""

Purpose: No method docstring.

Parameters: – self: Instance reference

create_feature (Line 504)
def create_feature(self, name, description, state):
    """Create a new feature."""

Purpose: Create a new feature.

Parameters: – self: Instance reference – name: Identifier or label – description: Parameter for description – state: Current workflow state

enable_feature (Line 513)
def enable_feature(self, name, strategy):
    """Enable a feature."""

Purpose: Enable a feature.

Parameters: – self: Instance reference – name: Identifier or label – strategy: Parameter for strategy

disable_feature (Line 522)
def disable_feature(self, name):
    """Disable a feature."""

Purpose: Disable a feature.

Parameters: – self: Instance reference – name: Identifier or label

is_enabled (Line 526)
def is_enabled(self, name):
    """Check if feature is enabled."""

Purpose: Check if feature is enabled.

Parameters: – self: Instance reference – name: Identifier or label

evaluate (Line 530)
def evaluate(self, name):
    """Evaluate feature toggle."""

Purpose: Evaluate feature toggle.

Parameters: – self: Instance reference – name: Identifier or label

get_feature_status (Line 534)
def get_feature_status(self, name):
    """Get feature status."""

Purpose: Get feature status.

Parameters: – self: Instance reference – name: Identifier or label

list_features (Line 538)
def list_features(self):
    """List all features."""

Purpose: List all features.

Parameters: – self: Instance reference

get_statistics (Line 542)
def get_statistics(self):
    """Get statistics."""

Purpose: Get statistics.

Parameters: – self: Instance reference

Design Patterns Used

  • Strategy Pattern: Different execution strategies for various scenarios
  • State Pattern: Managing different states in the workflow
  • Chain of Responsibility: Sequential processing through workflow nodes
  • Observer Pattern: Tracking and monitoring pattern execution
  • Factory Pattern: Creating instances with proper configuration

Usage Example

# Initialize the pattern
pattern = ToggleState(name="example", model_name="gpt-4")

# Configure and execute
result = pattern.execute(data={"key": "value"})

# Check results
print(result)

Key Concepts

  • LLM Integration: Uses LangChain/OpenAI for intelligent decision-making
  • Workflow Orchestration: LangGraph manages execution flow through nodes
  • State Management: TypedDict defines workflow state structure
  • Error Handling: Comprehensive error handling and fallback mechanisms
  • Extensibility: Designed for easy customization and extension

Extension Points

This pattern can be extended by: 1. Adding custom workflow nodes 2. Implementing additional validation logic 3. Integrating with external services 4. Customizing LLM prompts and responses 5. Adding monitoring and logging capabilities

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *

More posts