#06 - Beyond the Basics: Advanced Object-Oriented Programming in Python

Welcome to Day 6! Today we cover advanced Python object-oriented patterns and runtime capabilities. These tools allow you to write clean, reusable, and robust codebases without bloated boilerplate.

1. @classmethod vs @staticmethod: Understanding alternative constructor patterns vs pure utility functions.
2. Dataclasses: Automating boilerplate class definitions (__init__, __repr__, __eq__).
3. Mixins & Method Resolution Order (MRO): Composing reusable behavior across classes via C3 Linearization.
4. Type Inspection (isinstance / issubclass): Safely inspecting object types and class hierarchies at runtime.

---

1. @classmethod vs @staticmethod ⚙️

Both decorators create methods that can be called directly on a class without instantiating it first, but they serve different architectural roles:

┌─────────────────────────────────────────────────────────────────────────────┐
│                          CLASS VS STATIC METHODS                            │
├─────────────────┬─────────────────────────────┬─────────────────────────────┤
│ Feature         │ @classmethod                │ @staticmethod               │
├─────────────────┼─────────────────────────────┼─────────────────────────────┤
│ First Parameter │ `cls` (Implicit Class Ref)  │ None (Explicit Args Only)   │
│ Primary Purpose │ Alternative Constructors /  │ Pure Utility Functions /    │
│                 │ Modifying Class-Level State │ Namespace Grouping          │
│ Subclass Aware  │ Yes (instantiates child cls)│ No (has no class reference) │
└─────────────────┴─────────────────────────────┴─────────────────────────────┘

class DateFormatter:
    def __init__(self, year: int, month: int, day: int):
        self.year = year
        self.month = month
        self.day = day

    # Alternative Constructor
    @classmethod
    def from_string(cls, date_str: str) -> "DateFormatter":
        """Parses 'YYYY-MM-DD' and creates an instance of cls."""
        year, month, day = map(int, date_str.split("-"))
        return cls(year, month, day)  # 'cls' ensures inheritance safety

    # Pure Utility
    @staticmethod
    def is_valid_date(date_str: str) -> bool:
        """Utility check that doesn't need instance or class state."""
        parts = date_str.split("-")
        return len(parts) == 3 and all(p.isdigit() for p in parts)

# Usage:
if DateFormatter.is_valid_date("2026-08-15"):
    d = DateFormatter.from_string("2026-08-15")
    print(d.year)  # Output: 2026

---

2. Dataclasses (@dataclass) 📦

Introduced in Python 3.7, @dataclass automatically generates standard dunder methods (__init__, __repr__, __eq__, __hash__) based on type annotations.

from dataclasses import dataclass, field
from typing import List

@dataclass(frozen=True)  # frozen=True makes instances immutable & hashable!
class DatabaseConfig:
    host: str
    port: int = 5432
    # Use field(default_factory=...) for mutable defaults like lists/dicts!
    options: List[str] = field(default_factory=list)

cfg1 = DatabaseConfig(host="localhost")
cfg2 = DatabaseConfig(host="localhost")

print(cfg1)          # DatabaseConfig(host='localhost', port=5432, options=[])
print(cfg1 == cfg2)  # True (Value equality out of the box)

---

3. Mixins & Method Resolution Order (MRO) 🧬

A Mixin is a lightweight, single-purpose class designed to grant specific methods to child classes through multiple inheritance. Mixins shouldn't maintain state or be instantiated on their own.

When multiple inheritance is involved, Python uses C3 Linearization to calculate the Method Resolution Order (MRO)—the exact order Python searches for methods.

                  ┌─────────────────────┐
                  │    BaseService      │
                  └──────────┬──────────┘
                             │
            ┌────────────────┴────────────────┐
            ▼                                 ▼
┌───────────────────────┐         ┌───────────────────────┐
│  JSONSerializerMixin  │         │   AuditLoggerMixin    │
└───────────┬───────────┘         └───────────┬───────────┘
            │                                 │
            └────────────────┬────────────────┘
                             ▼
                  ┌─────────────────────┐
                  │   UserAuthService   │
                  └─────────────────────┘
 MRO Chain: UserAuthService -> JSONSerializerMixin -> AuditLoggerMixin -> BaseService -> object

You can inspect the MRO at any time using Class.mro() or Class.__mro__:

class BaseService:
    def execute(self):
        print("Executing BaseService")

class JSONSerializerMixin:
    def to_json(self):
        return f'{{"class": "{self.__class__.__name__}"}}'

class AuditLoggerMixin:
    def log(self, action: str):
        print(f"[AUDIT] {self.__class__.__name__}: {action}")

class UserAuthService(JSONSerializerMixin, AuditLoggerMixin, BaseService):
    pass

# View MRO Lookup Order
print(UserAuthService.mro())
# [<class 'UserAuthService'>, <class 'JSONSerializerMixin'>, <class 'AuditLoggerMixin'>, <class 'BaseService'>, <class 'object'>]

---

4. Runtime Type Inspection 🔍

In Python's dynamic type system, isinstance() and issubclass() allow you to verify types safely while respecting class hierarchies:

• isinstance(object, classinfo): Returns True if object is an instance of classinfo or any of its subclasses.
• issubclass(class, classinfo): Returns True if class is a direct or indirect subclass of classinfo.

svc = UserAuthService()

# Check instance
print(isinstance(svc, UserAuthService))      # True
print(isinstance(svc, JSONSerializerMixin))  # True (via inheritance!)
print(isinstance(svc, str))                  # False

# Check class relationship
print(issubclass(UserAuthService, BaseService))  # True
print(issubclass(BaseService, UserAuthService))  # False

---

5. Practice Challenge: Design Reusable Utility Framework 🛠️

Let's build an Enterprise Event & Audit Utility System that integrates Dataclasses, @classmethod, @staticmethod, Mixins, MRO, and Runtime Inspection.

Step 1: Initialize Your Workspace

uv init oop_day6 && cd oop_day6
touch utility_system.py

Step 2: Implement utility_system.py

# utility_system.py
from dataclasses import dataclass, field, asdict
from typing import Dict, Any, List, Type
import json
import time


# ==========================================
# 1. REUSABLE MIXINS
# ==========================================
class JSONSerializableMixin:
    """Mixin to add seamless JSON serialization to dataclasses or standard classes."""

    def to_json(self) -> str:
        """Converts object dictionary representation to a JSON string."""
        if hasattr(self, "__dataclass_fields__"):
            data = asdict(self)
        else:
            data = {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
        return json.dumps(data, indent=2)


class AuditLoggerMixin:
    """Mixin to inject time-stamped auditing behavior into any utility or service."""

    def log_event(self, action: str, details: str) -> None:
        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
        print(f"⏱️ [{timestamp}] [{self.__class__.__name__}] {action.upper()}: {details}")


# ==========================================
# 2. DATACLASS WITH CLASSMETHOD FACTORIES
# ==========================================
@dataclass(frozen=True)
class SystemConfig(JSONSerializableMixin):
    """Immutable configuration dataclass with factory constructors."""

    app_name: str
    environment: str
    max_connections: int = 100
    features: List[str] = field(default_factory=lambda: ["auth", "metrics"])

    # STATIC METHOD UTILITY
    @staticmethod
    def validate_env_name(env: str) -> bool:
        """Pure utility function to validate deployment environments."""
        return env.lower() in {"development", "staging", "production"}

    # CLASSMETHOD ALTERNATIVE CONSTRUCTORS
    @classmethod
    def from_dict(cls, data: Dict[str, Any]) -> "SystemConfig":
        """Factory method to construct config from a dictionary with validation."""
        env = data.get("environment", "development")
        if not cls.validate_env_name(env):
            raise ValueError(f"Invalid environment name: '{env}'")

        return cls(
            app_name=data.get("app_name", "DefaultApp"),
            environment=env.lower(),
            max_connections=int(data.get("max_connections", 100)),
            features=data.get("features", ["auth"])
        )

    @classmethod
    def default_dev_config(cls) -> "SystemConfig":
        """Factory method providing standard local development preset."""
        return cls(app_name="DevPortal", environment="development", max_connections=10)


# ==========================================
# 3. SERVICE INHERITING MIXINS (MRO DEMO)
# ==========================================
class AppEventManager(JSONSerializableMixin, AuditLoggerMixin):
    """Service demonstrating multiple inheritance mixins and event dispatching."""

    def __init__(self, config: SystemConfig):
        self.config = config
        self.events_processed = 0

    def dispatch(self, event_type: str, payload: Dict[str, Any]) -> None:
        self.events_processed += 1
        self.log_event("DISPATCH", f"Event '{event_type}' processed for {self.config.app_name}")


# ==========================================
# 4. INSPECTION ENGINE (isinstance / issubclass)
# ==========================================
class SystemAuditor:
    """Inspects runtime objects and class hierarchies."""

    @staticmethod
    def inspect_component(obj: Any) -> None:
        print("\n==================================================")
        print(f"      COMPONENT INSPECTION: {type(obj).__name__}    ")
        print("==================================================")

        # Check instance inheritance
        is_jsonable = isinstance(obj, JSONSerializableMixin)
        is_auditable = isinstance(obj, AuditLoggerMixin)

        print(f" • Implements JSONSerializableMixin? : {is_jsonable}")
        print(f" • Implements AuditLoggerMixin?      : {is_auditable}")

        # Demonstrate method resolution order if custom class
        obj_cls = obj if isinstance(obj, type) else type(obj)
        print("\n 🔍 Calculated Method Resolution Order (MRO):")
        for idx, cls_in_mro in enumerate(obj_cls.mro(), 1):
            print(f"    {idx}. {cls_in_mro.__name__}")
        print("--------------------------------------------------\n")


# ==========================================
# TEST EXECUTION SUITE
# ==========================================
if __name__ == "__main__":
    print("--- 1. Constructing Configs via @classmethod & @staticmethod ---")

    # Static method validation check
    print(f"Is 'production' valid env? {SystemConfig.validate_env_name('production')}")

    # Creating via classmethod factory
    raw_config_data = {
        "app_name": "PaymentGateway",
        "environment": "Production",
        "max_connections": 500,
        "features": ["auth", "stripe", "fraud_check"]
    }
    prod_config = SystemConfig.from_dict(raw_config_data)
    print(f"\nCreated Dataclass Config:\n{prod_config.to_json()}")

    print("\n--- 2. Executing Service with Mixin Capabilities ---")
    event_mgr = AppEventManager(prod_config)
    event_mgr.dispatch("USER_LOGIN", {"user_id": "usr_9921"})
    event_mgr.dispatch("PAYMENT_SUCCESS", {"amount": 149.99})

    print("\n--- 3. Runtime Inspection & MRO Analysis ---")
    # Inspecting Instance
    SystemAuditor.inspect_component(event_mgr)

    # Inspecting Class Relationships via issubclass
    print("Checking Class Hierarchy with issubclass():")
    print(f" • Is AppEventManager a subclass of AuditLoggerMixin? {issubclass(AppEventManager, AuditLoggerMixin)}")
    print(f" • Is SystemConfig a subclass of AuditLoggerMixin?    {issubclass(SystemConfig, AuditLoggerMixin)}")

Step 3: Run & Verify Execution

uv run utility_system.py

Output Summary

--- 1. Constructing Configs via @classmethod & @staticmethod ---
Is 'production' valid env? True

Created Dataclass Config:
{
  "app_name": "PaymentGateway",
  "environment": "production",
  "max_connections": 500,
  "features": [
    "auth",
    "stripe",
    "fraud_check"
  ]
}

--- 2. Executing Service with Mixin Capabilities ---
⏱️ [2026-08-15 20:48:36] [AppEventManager] DISPATCH: Event 'USER_LOGIN' processed for PaymentGateway
⏱️ [2026-08-15 20:48:36] [AppEventManager] DISPATCH: Event 'PAYMENT_SUCCESS' processed for PaymentGateway

--- 3. Runtime Inspection & MRO Analysis ---

==================================================
      COMPONENT INSPECTION: AppEventManager    
==================================================
 • Implements JSONSerializableMixin? : True
 • Implements AuditLoggerMixin?      : True

 🔍 Calculated Method Resolution Order (MRO):
    1. AppEventManager
    2. JSONSerializableMixin
    3. AuditLoggerMixin
    4. object
--------------------------------------------------

Checking Class Hierarchy with issubclass():
 • Is AppEventManager a subclass of AuditLoggerMixin? True
 • Is SystemConfig a subclass of AuditLoggerMixin?    False