Real-World Examples in Python Web Development

Let's create a file called real_world_examples.py that demonstrates how abstract classes and interfaces are used in actual web development contexts:

# File: abstract_classes/real_world_examples.py

import abc
from typing import Protocol, List, Dict, Any, Optional

# Example 1: ORM (Object-Relational Mapping) Models
class Model(abc.ABC):
    """Abstract base class for database models"""
    
    @classmethod
    @abc.abstractmethod
    def find_by_id(cls, id):
        """Find a record by ID"""
        pass
    
    @classmethod
    @abc.abstractmethod
    def find_all(cls):
        """Find all records"""
        pass
    
    @abc.abstractmethod
    def save(self):
        """Save the record to the database"""
        pass
    
    @abc.abstractmethod
    def delete(self):
        """Delete the record from the database"""
        pass


class SQLModel(Model):
    """SQL implementation of the Model class"""
    
    def __init__(self, **kwargs):
        self.id = kwargs.get('id')
        self._data = kwargs
    
    @classmethod
    def find_by_id(cls, id):
        print(f"SQL query: SELECT * FROM {cls.__name__.lower()} WHERE id = {id}")
        # Simulated database query
        return cls(id=id, name=f"Object {id}")
    
    @classmethod
    def find_all(cls):
        print(f"SQL query: SELECT * FROM {cls.__name__.lower()}")
        # Simulated database query
        return [cls(id=i, name=f"Object {i}") for i in range(1, 4)]
    
    def save(self):
        if self.id:
            print(f"SQL query: UPDATE {self.__class__.__name__.lower()} SET {self._data} WHERE id = {self.id}")
        else:
            print(f"SQL query: INSERT INTO {self.__class__.__name__.lower()} VALUES ({self._data})")
            self.id = 1  # Simulated ID assignment
        return True
    
    def delete(self):
        print(f"SQL query: DELETE FROM {self.__class__.__name__.lower()} WHERE id = {self.id}")
        return True


class User(SQLModel):
    """User model extending SQLModel"""
    
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.username = kwargs.get('username')
        self.email = kwargs.get('email')


# Example 2: Web Authentication Providers
class AuthProvider(abc.ABC):
    """Abstract base class for authentication providers"""
    
    @abc.abstractmethod
    def authenticate(self, username, password):
        """Authenticate a user"""
        pass
    
    @abc.abstractmethod
    def get_user(self, user_id):
        """Get a user by ID"""
        pass
    
    @abc.abstractmethod
    def create_user(self, username, password, **kwargs):
        """Create a new user"""
        pass


class LocalAuthProvider(AuthProvider):
    """Local database authentication provider"""
    
    def authenticate(self, username, password):
        print(f"Authenticating user {username} with local database")
        # Simulated authentication
        return {"id": 1, "username": username}
    
    def get_user(self, user_id):
        print(f"Getting user {user_id} from local database")
        # Simulated user retrieval
        return {"id": user_id, "username": f"user{user_id}"}
    
    def create_user(self, username, password, **kwargs):
        print(f"Creating user {username} in local database")
        # Simulated user creation
        return {"id": 1, "username": username}


class OAuth2Provider(AuthProvider):
    """OAuth2 authentication provider"""
    
    def __init__(self, provider_name, client_id, client_secret):
        self.provider_name = provider_name
        self.client_id = client_id
        self.client_secret = client_secret
    
    def authenticate(self, username, password):
        print(f"Authenticating user with {self.provider_name} OAuth2")
        # Simulated OAuth2 authentication
        return {"id": 1, "username": username, "oauth_provider": self.provider_name}
    
    def get_user(self, user_id):
        print(f"Getting user {user_id} from {self.provider_name} OAuth2")
        # Simulated user retrieval
        return {"id": user_id, "username": f"user{user_id}", "oauth_provider": self.provider_name}
    
    def create_user(self, username, password, **kwargs):
        print(f"Creating user {username} with {self.provider_name} OAuth2")
        # Simulated user creation
        return {"id": 1, "username": username, "oauth_provider": self.provider_name}


# Example 3: Template Rendering (using Protocol)
class TemplateRenderer(Protocol):
    """Protocol for template renderers"""
    
    def render(self, template_name: str, context: Dict[str, Any]) -> str:
        """Render a template with the given context"""
        ...


class JinjaRenderer:
    """Jinja2 template renderer"""
    
    def render(self, template_name: str, context: Dict[str, Any]) -> str:
        print(f"Rendering template {template_name} with Jinja2")
        # Simulated Jinja2 rendering
        return f"
{context.get('title', '')}
"


class MakoRenderer:
    """Mako template renderer"""
    
    def render(self, template_name: str, context: Dict[str, Any]) -> str:
        print(f"Rendering template {template_name} with Mako")
        # Simulated Mako rendering
        return f"
{context.get('title', '')}
"


# Example 4: Web Framework Request Handlers
class RequestHandler(abc.ABC):
    """Abstract base class for HTTP request handlers"""
    
    def __init__(self, request):
        self.request = request
    
    @abc.abstractmethod
    def get(self, *args, **kwargs):
        """Handle HTTP GET requests"""
        pass
    
    @abc.abstractmethod
    def post(self, *args, **kwargs):
        """Handle HTTP POST requests"""
        pass
    
    def handle_request(self, method, *args, **kwargs):
        """Dispatch the request to the appropriate method"""
        if method.lower() == 'get':
            return self.get(*args, **kwargs)
        elif method.lower() == 'post':
            return self.post(*args, **kwargs)
        return {"error": "Method not allowed"}


class HomeHandler(RequestHandler):
    """Home page handler"""
    
    def get(self, *args, **kwargs):
        return {"title": "Home Page", "content": "Welcome to our website!"}
    
    def post(self, *args, **kwargs):
        return {"error": "POST not supported on home page"}


class ContactHandler(RequestHandler):
    """Contact form handler"""
    
    def get(self, *args, **kwargs):
        return {"title": "Contact Us", "content": "Contact form"}
    
    def post(self, *args, **kwargs):
        return {"success": "Message sent successfully"}


# Test the examples
# Example 1: ORM Models
print("ORM Models Example:")
user = User(username="john", email="john@example.com")
user.save()
users = User.find_all()
print()

# Example 2: Authentication Providers
print("Authentication Providers Example:")
local_auth = LocalAuthProvider()
oauth_auth = OAuth2Provider("Google", "client123", "secret456")

local_user = local_auth.authenticate("john", "password123")
oauth_user = oauth_auth.authenticate("john", "token123")
print()

# Example 3: Template Renderers
print("Template Renderers Example:")
jinja = JinjaRenderer()
mako = MakoRenderer()

# We can use either renderer without checking its type
def render_page(renderer: TemplateRenderer, template_name: str, context: Dict[str, Any]) -> str:
    return renderer.render(template_name, context)

jinja_output = render_page(jinja, "home.html", {"title": "Home"})
mako_output = render_page(mako, "home.html", {"title": "Home"})
print()

# Example 4: Request Handlers
print("Request Handlers Example:")
# Simulate a request object
class Request:
    def __init__(self, method, path, data=None):
        self.method = method
        self.path = path
        self.data = data or {}

home_request = Request("GET", "/")
contact_get_request = Request("GET", "/contact")
contact_post_request = Request("POST", "/contact", {"email": "john@example.com", "message": "Hello!"})

home_handler = HomeHandler(home_request)
contact_handler = ContactHandler(contact_post_request)

print("Home Handler Result:")
print(home_handler.handle_request("GET"))
print("\nContact Handler Result:")
print(contact_handler.handle_request("POST"))

Code Breakdown:

• Example 1: Demonstrates an abstract Model class for an ORM (Object-Relational Mapping) system, similar to what you might find in Django or SQLAlchemy. The SQLModel implementation provides concrete methods for database operations, and the User class extends it for specific user-related functionality.
• Example 2: Shows an authentication system with an abstract AuthProvider class and two implementations: LocalAuthProvider for database authentication and OAuth2Provider for OAuth2-based authentication. This pattern allows swapping authentication providers without changing the application code.
• Example 3: Uses the Protocol approach to define a TemplateRenderer interface. Both JinjaRenderer and MakoRenderer implement this protocol, allowing them to be used interchangeably in the render_page function.
• Example 4: Implements a request handling system similar to web frameworks like Flask or Django. The abstract RequestHandler class defines the interface for handling HTTP requests, and concrete handlers like HomeHandler and ContactHandler implement specific behavior for different routes.

These examples show how abstract classes and interfaces are fundamental to modern web development frameworks and libraries. They enable modular, extensible, and maintainable code by separating interface from implementation and allowing components to be swapped or extended easily.