Real-World Examples in Web Development

Let's explore some real-world examples of how class methods and static methods are used in Python web development. Create a file named real_world_examples.py with the following code:

# File: class_methods/real_world_examples.py

import os
import re
import hashlib
import json
from datetime import datetime, timedelta
from urllib.parse import urljoin, urlparse


class Config:
    """A configuration class that uses class methods to load and manage configuration settings"""
    
    # Class variables to store configuration settings
    _config = {}
    _instance = None
    
    def __init__(self):
        """Private constructor to prevent direct instantiation"""
        raise RuntimeError("Use Config.get_instance() to get the Config instance")
    
    @classmethod
    def get_instance(cls):
        """Get the singleton instance of Config (lazy initialization)"""
        if cls._instance is None:
            # Create the instance without calling __init__
            cls._instance = cls.__new__(cls)
            cls._instance._config = {}
        return cls._instance
    
    @classmethod
    def load_from_file(cls, file_path):
        """Load configuration from a JSON file"""
        try:
            with open(file_path, 'r') as file:
                config = json.load(file)
                cls._config.update(config)
            return True
        except Exception as e:
            print(f"Error loading configuration from {file_path}: {e}")
            return False
    
    @classmethod
    def load_from_env(cls, prefix='APP_'):
        """Load configuration from environment variables with a specific prefix"""
        for key, value in os.environ.items():
            if key.startswith(prefix):
                config_key = key[len(prefix):].lower()
                cls._config[config_key] = value
    
    @classmethod
    def get(cls, key, default=None):
        """Get a configuration value by key"""
        return cls._config.get(key, default)
    
    @classmethod
    def set(cls, key, value):
        """Set a configuration value"""
        cls._config[key] = value


class User:
    """A user class that uses class methods for different user types and static methods for validation"""
    
    # Class variable to track all users
    _users = {}
    
    def __init__(self, username, email, password, role='user'):
        self.username = username
        self.email = email
        self._password_hash = self._hash_password(password)
        self.role = role
        self.created_at = datetime.now()
        self.last_login = None
        
        # Add to users dictionary
        User._users[username] = self
    
    def __str__(self):
        return f"User({self.username}, {self.email}, role={self.role})"
    
    def check_password(self, password):
        """Check if the provided password matches the stored hash"""
        return self._password_hash == self._hash_password(password)
    
    def login(self):
        """Record a login"""
        self.last_login = datetime.now()
    
    @staticmethod
    def _hash_password(password):
        """Hash a password using SHA-256 (in a real app, use bcrypt or another secure method)"""
        return hashlib.sha256(password.encode()).hexdigest()
    
    @staticmethod
    def validate_username(username):
        """Validate a username (static method because it doesn't use any instance or class state)"""
        if not username or not isinstance(username, str):
            return False
        # Username should be 3-20 characters, alphanumeric with underscores
        return bool(re.match(r'^[a-zA-Z0-9_]{3,20}$', username))
    
    @staticmethod
    def validate_email(email):
        """Validate an email address (simplified)"""
        if not email or not isinstance(email, str):
            return False
        # Simple email validation
        return bool(re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', email))
    
    @staticmethod
    def validate_password(password):
        """Validate a password (simplified)"""
        if not password or not isinstance(password, str):
            return False
        # Password should be at least 8 characters with at least one letter and one number
        return len(password) >= 8 and any(c.isalpha() for c in password) and any(c.isdigit() for c in password)
    
    @classmethod
    def get_user(cls, username):
        """Get a user by username"""
        return cls._users.get(username)
    
    @classmethod
    def create_admin(cls, username, email, password):
        """Create an admin user"""
        # Validate inputs
        if not cls.validate_username(username) or not cls.validate_email(email) or not cls.validate_password(password):
            raise ValueError("Invalid username, email, or password")
        
        # Create an admin user
        return cls(username, email, password, role='admin')
    
    @classmethod
    def create_moderator(cls, username, email, password):
        """Create a moderator user"""
        # Validate inputs
        if not cls.validate_username(username) or not cls.validate_email(email) or not cls.validate_password(password):
            raise ValueError("Invalid username, email, or password")
        
        # Create a moderator user
        return cls(username, email, password, role='moderator')


class URL:
    """A URL utility class that uses static methods for URL operations"""
    
    @staticmethod
    def is_valid(url):
        """Check if a URL is valid"""
        try:
            result = urlparse(url)
            return all([result.scheme, result.netloc])
        except:
            return False
    
    @staticmethod
    def join(base, path):
        """Join a base URL and a path"""
        return urljoin(base, path)
    
    @staticmethod
    def get_domain(url):
        """Extract the domain from a URL"""
        return urlparse(url).netloc
    
    @staticmethod
    def remove_query_params(url):
        """Remove query parameters from a URL"""
        parsed = urlparse(url)
        return f"{parsed.scheme}://{parsed.netloc}{parsed.path}"


class Session:
    """A session class that uses class methods for session management and static methods for utilities"""
    
    # Class variable to store all active sessions
    _sessions = {}
    
    def __init__(self, user_id, ip_address=None):
        self.session_id = self._generate_session_id()
        self.user_id = user_id
        self.ip_address = ip_address
        self.created_at = datetime.now()
        self.expires_at = self.created_at + timedelta(hours=24)  # 24-hour expiration
        self.data = {}
        
        # Add to sessions dictionary
        Session._sessions[self.session_id] = self
    
    def __str__(self):
        return f"Session({self.session_id}, user_id={self.user_id}, expires={self.expires_at})"
    
    def is_expired(self):
        """Check if the session is expired"""
        return datetime.now() > self.expires_at
    
    @staticmethod
    def _generate_session_id():
        """Generate a unique session ID"""
        # In a real app, use a more secure method
        return hashlib.md5(str(datetime.now().timestamp()).encode()).hexdigest()
    
    @classmethod
    def get_session(cls, session_id):
        """Get a session by ID"""
        session = cls._sessions.get(session_id)
        if session and not session.is_expired():
            return session
        # Remove expired session
        if session:
            del cls._sessions[session_id]
        return None
    
    @classmethod
    def get_sessions_for_user(cls, user_id):
        """Get all sessions for a user"""
        return [session for session in cls._sessions.values() if session.user_id == user_id and not session.is_expired()]
    
    @classmethod
    def clear_expired_sessions(cls):
        """Clear all expired sessions"""
        expired_sessions = [sid for sid, session in cls._sessions.items() if session.is_expired()]
        for sid in expired_sessions:
            del cls._sessions[sid]
        return len(expired_sessions)


class Response:
    """A simple HTTP response class with static methods for common responses"""
    
    def __init__(self, content, status_code=200, headers=None):
        self.content = content
        self.status_code = status_code
        self.headers = headers or {}
    
    def __str__(self):
        return f"Response({self.status_code}, {len(self.content)} bytes)"
    
    @staticmethod
    def json(data, status_code=200, headers=None):
        """Create a JSON response"""
        headers = headers or {}
        headers['Content-Type'] = 'application/json'
        return Response(json.dumps(data), status_code, headers)
    
    @staticmethod
    def html(content, status_code=200, headers=None):
        """Create an HTML response"""
        headers = headers or {}
        headers['Content-Type'] = 'text/html'
        return Response(content, status_code, headers)
    
    @staticmethod
    def redirect(url, permanent=False):
        """Create a redirect response"""
        status_code = 301 if permanent else 302
        headers = {'Location': url}
        return Response('', status_code, headers)
    
    @staticmethod
    def not_found():
        """Create a 404 Not Found response"""
        return Response('Not Found', 404)
    
    @staticmethod
    def server_error(error_message='Internal Server Error'):
        """Create a 500 Internal Server Error response"""
        return Response(error_message, 500)


# Using the Config class (Singleton pattern with class methods)
print("Config example:")
config = Config.get_instance()
Config.set('debug', True)
Config.set('database_url', 'postgres://user:pass@localhost/mydb')
print(f"Debug mode: {Config.get('debug')}")
print(f"Database URL: {Config.get('database_url')}")

# Using the User class (factory methods and static validators)
print("\nUser example:")
try:
    # Validate inputs using static methods
    username = "john_doe"
    email = "john@example.com"
    password = "p@ssw0rd123"
    
    if User.validate_username(username) and User.validate_email(email) and User.validate_password(password):
        # Create users using different factory methods
        admin = User.create_admin("admin", "admin@example.com", "Admin123!")
        moderator = User.create_moderator("moderator", "mod@example.com", "Mod123!")
        regular_user = User(username, email, password)
        
        print(f"Created users: {admin}, {moderator}, {regular_user}")
        
        # Log in a user
        user = User.get_user(username)
        if user and user.check_password(password):
            user.login()
            print(f"User {username} logged in at {user.last_login}")
    else:
        print("Invalid username, email, or password")
except ValueError as e:
    print(f"Error: {e}")

# Using the URL class (static utility methods)
print("\nURL example:")
base_url = "https://example.com/api"
path = "/users/profile"
full_url = URL.join(base_url, path)
print(f"Joined URL: {full_url}")
print(f"Domain: {URL.get_domain(full_url)}")
url_with_params = f"{full_url}?user_id=123&format=json"
print(f"URL without params: {URL.remove_query_params(url_with_params)}")

# Using the Session class (class methods for management)
print("\nSession example:")
session1 = Session("user123", "192.168.1.1")
session2 = Session("user123", "192.168.1.2")
session3 = Session("user456", "192.168.1.3")

print(f"Created sessions: {session1}, {session2}, {session3}")
print(f"Sessions for user123: {Session.get_sessions_for_user('user123')}")

# Force session1 to expire
session1.expires_at = datetime.now() - timedelta(minutes=1)
cleared = Session.clear_expired_sessions()
print(f"Cleared {cleared} expired sessions")
print(f"Sessions for user123 after cleanup: {Session.get_sessions_for_user('user123')}")

# Using the Response class (static factory methods)
print("\nResponse example:")
json_response = Response.json({"status": "success", "data": {"user_id": 123}})
html_response = Response.html("
Hello, World!
")
redirect_response = Response.redirect("https://example.com/login")
not_found_response = Response.not_found()
error_response = Response.server_error("Database connection failed")

print(f"JSON Response: {json_response}")
print(f"HTML Response: {html_response}")
print(f"Redirect Response: {redirect_response}")
print(f"Not Found Response: {not_found_response}")
print(f"Error Response: {error_response}")

Code Breakdown:

• Config class demonstrates:
  • Using class methods to implement the Singleton pattern
  • Loading configuration from different sources (files, environment variables)
  • Providing a centralized way to access configuration settings
• User class demonstrates:
  • Using static methods for validation functions
  • Using class methods for creating different types of users
  • Storing and retrieving users in a class variable
• URL class demonstrates:
  • Using static methods for URL-related utility functions
  • Grouping related functions under a namespace
• Session class demonstrates:
  • Using class methods for session management
  • Using static methods for helper functions
• Response class demonstrates:
  • Using static methods as factory methods for different types of HTTP responses
  • Creating specialized response objects based on common patterns

These examples show how class methods and static methods are commonly used in real-world web development to implement design patterns, provide utility functions, manage resources, and create factory methods for specialized objects.