Real-World Examples of Polymorphism in Python Web Development

Let's create a file called real_world_examples.py that demonstrates how polymorphism is used in actual web development contexts:

# File: polymorphism/real_world_examples.py

from abc import ABC, abstractmethod
from datetime import datetime
import json

# Example 1: Database Adapters with Polymorphism
class DatabaseAdapter(ABC):
    """Abstract base class for database adapters"""
    
    @abstractmethod
    def connect(self):
        """Connect to the database"""
        pass
    
    @abstractmethod
    def execute(self, query, params=None):
        """Execute a query"""
        pass
    
    @abstractmethod
    def fetch_one(self):
        """Fetch a single result"""
        pass
    
    @abstractmethod
    def fetch_all(self):
        """Fetch all results"""
        pass
    
    @abstractmethod
    def close(self):
        """Close the connection"""
        pass


class PostgreSQLAdapter(DatabaseAdapter):
    """PostgreSQL database adapter"""
    
    def connect(self):
        print("Connecting to PostgreSQL database")
        # In a real implementation, this would use psycopg2 or another PostgreSQL driver
        return self
    
    def execute(self, query, params=None):
        param_str = str(params) if params else "none"
        print(f"Executing PostgreSQL query: {query} with params: {param_str}")
        return self
    
    def fetch_one(self):
        print("Fetching one result from PostgreSQL")
        # Simulated result
        return {"id": 1, "name": "John Doe"}
    
    def fetch_all(self):
        print("Fetching all results from PostgreSQL")
        # Simulated results
        return [
            {"id": 1, "name": "John Doe"},
            {"id": 2, "name": "Jane Smith"}
        ]
    
    def close(self):
        print("Closing PostgreSQL connection")


class MySQLAdapter(DatabaseAdapter):
    """MySQL database adapter"""
    
    def connect(self):
        print("Connecting to MySQL database")
        # In a real implementation, this would use mysql-connector or another MySQL driver
        return self
    
    def execute(self, query, params=None):
        param_str = str(params) if params else "none"
        print(f"Executing MySQL query: {query} with params: {param_str}")
        return self
    
    def fetch_one(self):
        print("Fetching one result from MySQL")
        # Simulated result
        return {"id": 1, "name": "John Doe"}
    
    def fetch_all(self):
        print("Fetching all results from MySQL")
        # Simulated results
        return [
            {"id": 1, "name": "John Doe"},
            {"id": 2, "name": "Jane Smith"}
        ]
    
    def close(self):
        print("Closing MySQL connection")


class SQLiteAdapter(DatabaseAdapter):
    """SQLite database adapter"""
    
    def connect(self):
        print("Connecting to SQLite database")
        # In a real implementation, this would use sqlite3
        return self
    
    def execute(self, query, params=None):
        param_str = str(params) if params else "none"
        print(f"Executing SQLite query: {query} with params: {param_str}")
        return self
    
    def fetch_one(self):
        print("Fetching one result from SQLite")
        # Simulated result
        return {"id": 1, "name": "John Doe"}
    
    def fetch_all(self):
        print("Fetching all results from SQLite")
        # Simulated results
        return [
            {"id": 1, "name": "John Doe"},
            {"id": 2, "name": "Jane Smith"}
        ]
    
    def close(self):
        print("Closing SQLite connection")


# Example 2: Form Validation
class ValidationRule(ABC):
    """Abstract base class for validation rules"""
    
    @abstractmethod
    def validate(self, value):
        """Validate a value against this rule"""
        pass


class RequiredRule(ValidationRule):
    """Validation rule requiring a non-empty value"""
    
    def validate(self, value):
        if not value:
            return False, "This field is required"
        return True, None


class MinLengthRule(ValidationRule):
    """Validation rule requiring a minimum length"""
    
    def __init__(self, min_length):
        self.min_length = min_length
    
    def validate(self, value):
        if len(str(value)) < self.min_length:
            return False, f"Must be at least {self.min_length} characters"
        return True, None


class EmailRule(ValidationRule):
    """Validation rule requiring an email format"""
    
    def validate(self, value):
        if not isinstance(value, str) or '@' not in value or '.' not in value:
            return False, "Must be a valid email address"
        return True, None


class NumericRule(ValidationRule):
    """Validation rule requiring a numeric value"""
    
    def validate(self, value):
        try:
            float(value)
            return True, None
        except (ValueError, TypeError):
            return False, "Must be a number"


class FormValidator:
    """Form validator that can use different validation rules"""
    
    def __init__(self, fields):
        self.fields = fields  # Dictionary of field_name: [rules]
    
    def validate(self, data):
        errors = {}
        
        for field_name, rules in self.fields.items():
            field_value = data.get(field_name, '')
            
            for rule in rules:
                is_valid, error_message = rule.validate(field_value)
                if not is_valid:
                    if field_name not in errors:
                        errors[field_name] = []
                    errors[field_name].append(error_message)
                    break  # Stop checking this field once an error is found
        
        return len(errors) == 0, errors


# Example 3: Template Rendering
class TemplateRenderer(ABC):
    """Abstract base class for template renderers"""
    
    @abstractmethod
    def render(self, template_name, context):
        """Render a template with the given context"""
        pass


class SimpleRenderer(TemplateRenderer):
    """Simple string-replacement template renderer"""
    
    def render(self, template_name, context):
        with open(template_name, 'r') as file:
            template = file.read()
        
        # Simple string replacement
        for key, value in context.items():
            placeholder = f"{{{{ {key} }}}}"
            template = template.replace(placeholder, str(value))
        
        return template


class JinjaLikeRenderer(TemplateRenderer):
    """Jinja-like template renderer with more features"""
    
    def render(self, template_name, context):
        with open(template_name, 'r') as file:
            template = file.read()
        
        # This is a very simplified version of Jinja-like rendering
        # In a real implementation, this would use actual Jinja2
        
        # Replace variables
        for key, value in context.items():
            placeholder = f"{{{{ {key} }}}}"
            template = template.replace(placeholder, str(value))
        
        # Handle simple conditionals (very simplified)
        import re
        pattern = r"{{% if (\w+) %}}(.*?){{% endif %}}"
        matches = re.finditer(pattern, template, re.DOTALL)
        
        for match in matches:
            var_name = match.group(1)
            content = match.group(2)
            
            if context.get(var_name):
                template = template.replace(match.group(0), content)
            else:
                template = template.replace(match.group(0), '')
        
        return template


# Example 4: Serialization
class Serializer(ABC):
    """Abstract base class for serializers"""
    
    @abstractmethod
    def serialize(self, obj):
        """Serialize an object to a string"""
        pass
    
    @abstractmethod
    def deserialize(self, data):
        """Deserialize a string to an object"""
        pass


class JSONSerializer(Serializer):
    """JSON serializer"""
    
    def serialize(self, obj):
        return json.dumps(obj)
    
    def deserialize(self, data):
        return json.loads(data)


class XMLSerializer(Serializer):
    """Simplified XML serializer"""
    
    def serialize(self, obj):
        if isinstance(obj, dict):
            xml_parts = ['']
            for key, value in obj.items():
                xml_parts.append(f'<{key}>{value}')
            xml_parts.append('')
            return '\n'.join(xml_parts)
        elif isinstance(obj, list):
            xml_parts = ['']
            for item in obj:
                xml_parts.append(f'{item}')
            xml_parts.append('')
            return '\n'.join(xml_parts)
        else:
            return f'{obj}'
    
    def deserialize(self, data):
        # This is a very simplified XML parser, not for production use
        import re
        result = {}
        
        # Extract key-value pairs
        pattern = r'<(\w+)>(.*?)'
        matches = re.finditer(pattern, data)
        
        for match in matches:
            key = match.group(1)
            value = match.group(2)
            
            if key != 'root':
                result[key] = value
        
        return result


# Test the database adapters
def fetch_user(adapter, user_id):
    """Fetch a user using any database adapter"""
    adapter.connect().execute("SELECT * FROM users WHERE id = %s", [user_id])
    user = adapter.fetch_one()
    adapter.close()
    return user

print("Database Adapters Example:")
postgres_adapter = PostgreSQLAdapter()
mysql_adapter = MySQLAdapter()
sqlite_adapter = SQLiteAdapter()

user1 = fetch_user(postgres_adapter, 1)
user2 = fetch_user(mysql_adapter, 1)
user3 = fetch_user(sqlite_adapter, 1)

# Test the form validator
print("\nForm Validation Example:")
user_form_validator = FormValidator({
    'username': [RequiredRule(), MinLengthRule(3)],
    'email': [RequiredRule(), EmailRule()],
    'age': [RequiredRule(), NumericRule()]
})

valid_data = {
    'username': 'john_doe',
    'email': 'john@example.com',
    'age': '30'
}

invalid_data = {
    'username': '',
    'email': 'not-an-email',
    'age': 'thirty'
}

is_valid, errors = user_form_validator.validate(valid_data)
print(f"Valid data: {is_valid}, Errors: {errors}")

is_valid, errors = user_form_validator.validate(invalid_data)
print(f"Invalid data: {is_valid}, Errors: {errors}")

# Test the template renderers (assuming template files exist)
"""
# Create test template files
with open('simple_template.html', 'w') as f:
    f.write("
{{ title }}
{{ content }}
")

with open('conditional_template.html', 'w') as f:
    f.write("
{{ title }}
{{ content }}
{% if show_footer %}{% endif %}")

print("\nTemplate Rendering Example:")
simple_renderer = SimpleRenderer()
jinja_renderer = JinjaLikeRenderer()

context = {
    'title': 'Welcome',
    'content': 'This is a test page',
    'show_footer': True,
    'footer': 'Copyright 2023'
}

simple_output = simple_renderer.render('simple_template.html', context)
jinja_output = jinja_renderer.render('conditional_template.html', context)

print(f"Simple renderer output: {simple_output[:50]}...")
print(f"Jinja-like renderer output: {jinja_output[:50]}...")
"""

# Test the serializers
print("\nSerialization Example:")
json_serializer = JSONSerializer()
xml_serializer = XMLSerializer()

data = {
    'name': 'John Doe',
    'email': 'john@example.com',
    'age': 30
}

json_data = json_serializer.serialize(data)
xml_data = xml_serializer.serialize(data)

print(f"JSON serialized data: {json_data}")
print(f"XML serialized data: {xml_data}")

json_obj = json_serializer.deserialize(json_data)
xml_obj = xml_serializer.deserialize(xml_data)

print(f"JSON deserialized object: {json_obj}")
print(f"XML deserialized object: {xml_obj}")

Code Breakdown:

• Example 1: Database Adapters
  • We define an abstract DatabaseAdapter class with methods like connect, execute, fetch_one, etc.
  • Concrete adapter classes (PostgreSQLAdapter, MySQLAdapter, SQLiteAdapter) implement these methods for specific database systems.
  • The fetch_user function demonstrates polymorphism by working with any database adapter, regardless of the specific implementation.
• Example 2: Form Validation
  • We define a ValidationRule abstract class with a validate method.
  • Concrete rule classes (RequiredRule, MinLengthRule, EmailRule, NumericRule) implement this method for specific validation requirements.
  • The FormValidator class works with any validation rule, demonstrating polymorphism through composition.
• Example 3: Template Rendering
  • We define a TemplateRenderer abstract class with a render method.
  • Concrete renderer classes (SimpleRenderer, JinjaLikeRenderer) implement this method with different template rendering strategies.
  • The same template context can be used with different renderers, demonstrating polymorphism.
• Example 4: Serialization
  • We define a Serializer abstract class with serialize and deserialize methods.
  • Concrete serializer classes (JSONSerializer, XMLSerializer) implement these methods for different serialization formats.
  • The same data can be serialized in different formats using different serializers, demonstrating polymorphism.

These examples show how polymorphism is fundamental to modern web development frameworks and libraries. It enables modular, extensible, and maintainable code by allowing components to be swapped or extended easily without changing the code that uses them.