Python Full Stack Web Developer Course

Real-World Examples

Let's look at some real-world examples of how dunder methods are used in practice. Create a file named real_world_examples.py with the following code:

# File: dunder_methods/real_world_examples.py

import json
import os
from datetime import datetime, timedelta
from functools import wraps
import time


class APIResponse:
    """A class representing an API response"""
    
    def __init__(self, data=None, status_code=200, message=None):
        self.data = data
        self.status_code = status_code
        self.message = message
        self.timestamp = datetime.now()
    
    def __str__(self):
        """String representation for users"""
        if self.message:
            return f"[{self.status_code}] {self.message}"
        return f"[{self.status_code}] {'Success' if self.status_code < 400 else 'Error'}"
    
    def __repr__(self):
        """Detailed representation for developers"""
        return f"APIResponse(status_code={self.status_code}, message='{self.message}', data={self.data})"
    
    def __bool__(self):
        """Return True if the response is successful (status_code < 400)"""
        return self.status_code < 400
    
    def __getitem__(self, key):
        """Allow accessing data attributes using dictionary notation"""
        if not self.data:
            raise KeyError(key)
        if isinstance(self.data, dict):
            return self.data[key]
        raise TypeError("Response data is not a dictionary")
    
    def to_dict(self):
        """Convert the response to a dictionary"""
        return {
            'status_code': self.status_code,
            'message': self.message,
            'data': self.data,
            'timestamp': self.timestamp.isoformat()
        }
    
    def to_json(self):
        """Convert the response to a JSON string"""
        return json.dumps(self.to_dict(), default=str)


class ExponentialBackoff:
    """A callable object implementing exponential backoff for retries"""
    
    def __init__(self, initial_delay=1, max_delay=60, factor=2, max_retries=5):
        self.initial_delay = initial_delay
        self.max_delay = max_delay
        self.factor = factor
        self.max_retries = max_retries
        self.retries = 0
    
    def __call__(self):
        """Return the next delay time in seconds"""
        if self.retries >= self.max_retries:
            raise Exception(f"Maximum retries ({self.max_retries}) exceeded")
        
        delay = min(self.initial_delay * (self.factor ** self.retries), self.max_delay)
        self.retries += 1
        return delay
    
    def reset(self):
        """Reset retry counter"""
        self.retries = 0


def retry_with_backoff(func):
    """Decorator to retry a function with exponential backoff"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        backoff = ExponentialBackoff()
        while True:
            try:
                return func(*args, **kwargs)
            except Exception as e:
                try:
                    delay = backoff()
                    print(f"Error: {e}. Retrying in {delay} seconds...")
                    time.sleep(delay)
                except Exception as backoff_error:
                    print(f"Giving up after {backoff.retries} retries: {e}")
                    raise e
    return wrapper


class ConfigDict:
    """A dictionary-like configuration class with dot notation access"""
    
    def __init__(self, config=None):
        self._config = {}
        if config:
            for key, value in config.items():
                self[key] = value
    
    def __getitem__(self, key):
        """Access config items with dictionary notation"""
        return self._config[key]
    
    def __setitem__(self, key, value):
        """Set config items with dictionary notation"""
        # If the value is a dictionary, convert it to a ConfigDict
        if isinstance(value, dict):
            value = ConfigDict(value)
        self._config[key] = value
    
    def __delitem__(self, key):
        """Delete config items with dictionary notation"""
        del self._config[key]
    
    def __contains__(self, key):
        """Check if config contains a key"""
        return key in self._config
    
    def __getattr__(self, name):
        """Access config items with dot notation"""
        if name in self._config:
            return self._config[name]
        raise AttributeError(f"No configuration setting named '{name}'")
    
    def __setattr__(self, name, value):
        """Set config items with dot notation"""
        if name == '_config':
            # Allow setting the internal _config dictionary
            super().__setattr__(name, value)
        else:
            # Set other attributes in the config dictionary
            self[name] = value
    
    def __iter__(self):
        """Iterate over config keys"""
        return iter(self._config)
    
    def __len__(self):
        """Get the number of config items"""
        return len(self._config)
    
    def get(self, key, default=None):
        """Get a config item with a default value"""
        return self._config.get(key, default)


class Cache:
    """A simple cache with expiring entries"""
    
    def __init__(self, default_ttl=300):  # Default TTL: 5 minutes
        self._cache = {}
        self._expiry = {}
        self.default_ttl = default_ttl
    
    def __getitem__(self, key):
        """Get an item from the cache, checking for expiration"""
        if key not in self._cache:
            raise KeyError(key)
        
        # Check if the entry has expired
        if key in self._expiry and datetime.now() > self._expiry[key]:
            # Remove expired entry
            del self._cache[key]
            del self._expiry[key]
            raise KeyError(f"Cache entry '{key}' has expired")
        
        return self._cache[key]
    
    def __setitem__(self, key, value):
        """Set an item in the cache with default TTL"""
        self.set(key, value, self.default_ttl)
    
    def __delitem__(self, key):
        """Delete an item from the cache"""
        if key in self._cache:
            del self._cache[key]
        if key in self._expiry:
            del self._expiry[key]
    
    def __contains__(self, key):
        """Check if key is in the cache and not expired"""
        if key not in self._cache:
            return False
        
        # Check if the entry has expired
        if key in self._expiry and datetime.now() > self._expiry[key]:
            # Remove expired entry
            del self._cache[key]
            del self._expiry[key]
            return False
        
        return True
    
    def set(self, key, value, ttl=None):
        """Set an item in the cache with a specific TTL"""
        self._cache[key] = value
        
        if ttl is not None:
            self._expiry[key] = datetime.now() + timedelta(seconds=ttl)
    
    def get(self, key, default=None):
        """Get an item from the cache or return default"""
        try:
            return self[key]
        except KeyError:
            return default
    
    def clear(self):
        """Clear the cache"""
        self._cache.clear()
        self._expiry.clear()


class FileSystemStorage:
    """A class for managing file storage with context manager support"""
    
    def __init__(self, base_path):
        self.base_path = base_path
        self.file = None
    
    def __enter__(self):
        """Context manager entry point"""
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        """Context manager exit point"""
        if self.file:
            self.file.close()
            self.file = None
    
    def __getitem__(self, file_path):
        """Read file content using dictionary notation"""
        full_path = os.path.join(self.base_path, file_path)
        try:
            with open(full_path, 'r') as f:
                return f.read()
        except FileNotFoundError:
            raise KeyError(f"File not found: {file_path}")
    
    def __setitem__(self, file_path, content):
        """Write file content using dictionary notation"""
        full_path = os.path.join(self.base_path, file_path)
        os.makedirs(os.path.dirname(full_path), exist_ok=True)
        with open(full_path, 'w') as f:
            f.write(content)
    
    def __delitem__(self, file_path):
        """Delete a file using dictionary notation"""
        full_path = os.path.join(self.base_path, file_path)
        if not os.path.exists(full_path):
            raise KeyError(f"File not found: {file_path}")
        os.remove(full_path)
    
    def __contains__(self, file_path):
        """Check if a file exists using 'in' operator"""
        full_path = os.path.join(self.base_path, file_path)
        return os.path.exists(full_path)
    
    def open(self, file_path, mode='r'):
        """Open a file and return the file object"""
        full_path = os.path.join(self.base_path, file_path)
        os.makedirs(os.path.dirname(full_path), exist_ok=True)
        self.file = open(full_path, mode)
        return self.file
    
    def list_files(self):
        """List all files in the storage"""
        files = []
        for root, _, filenames in os.walk(self.base_path):
            for filename in filenames:
                full_path = os.path.join(root, filename)
                rel_path = os.path.relpath(full_path, self.base_path)
                files.append(rel_path)
        return files


# Demo real-world examples
if __name__ == "__main__":
    # APIResponse example
    print("APIResponse example:")
    success_response = APIResponse(
        data={"user_id": 123, "username": "john_doe"},
        status_code=200,
        message="User retrieved successfully"
    )
    
    error_response = APIResponse(
        status_code=404,
        message="User not found"
    )
    
    print(f"Success response: {success_response}")
    print(f"Error response: {error_response}")
    
    # Using __bool__
    if success_response:
        print("Success response evaluated as True")
    
    if not error_response:
        print("Error response evaluated as False")
    
    # Using __getitem__
    print(f"User ID: {success_response['user_id']}")
    print(f"Username: {success_response['username']}")
    
    # ExponentialBackoff example
    print("\nExponentialBackoff example:")
    backoff = ExponentialBackoff(initial_delay=0.1, max_delay=2, factor=2, max_retries=5)
    
    for _ in range(5):
        delay = backoff()
        print(f"Retry in {delay} seconds")
    
    try:
        backoff()  # This should exceed max retries
    except Exception as e:
        print(f"Error: {e}")
    
    # ConfigDict example
    print("\nConfigDict example:")
    config = ConfigDict({
        'app': {
            'name': 'My App',
            'version': '1.0.0'
        },
        'database': {
            'host': 'localhost',
            'port': 5432,
            'user': 'admin'
        },
        'debug': True
    })
    
    # Access with dot notation
    print(f"App name: {config.app.name}")
    print(f"Database host: {config.database.host}")
    print(f"Debug mode: {config.debug}")
    
    # Access with dictionary notation
    print(f"App version: {config['app']['version']}")
    print(f"Database port: {config['database']['port']}")
    
    # Modify with dot notation
    config.app.version = '1.1.0'
    print(f"Updated app version: {config.app.version}")
    
    # Add new settings
    config.logging = {'level': 'INFO'}
    print(f"Logging level: {config.logging.level}")
    
    # Cache example
    print("\nCache example:")
    cache = Cache(default_ttl=2)  # 2 seconds TTL for testing
    
    cache['key1'] = 'value1'
    cache.set('key2', 'value2', ttl=5)  # 5 seconds TTL
    
    print(f"key1 in cache: {cache.get('key1')}")
    print(f"key2 in cache: {cache.get('key2')}")
    print(f"key3 in cache: {cache.get('key3', 'default')}")
    
    print("Waiting for key1 to expire...")
    time.sleep(3)
    
    print(f"key1 in cache: {cache.get('key1', 'expired')}")
    print(f"key2 in cache: {cache.get('key2', 'expired')}")
    
    # FileSystemStorage example (commented out to avoid actual file operations)
    """
    print("\nFileSystemStorage example:")
    storage = FileSystemStorage("./temp_storage")
    
    with storage:
        # Write files
        storage['test.txt'] = 'Hello, World!'
        storage['folder/nested.txt'] = 'Nested file content'
        
        # Read files
        print(f"test.txt content: {storage['test.txt']}")
        print(f"folder/nested.txt content: {storage['folder/nested.txt']}")
        
        # Check if file exists
        print(f"'test.txt' exists: {'test.txt' in storage}")
        print(f"'nonexistent.txt' exists: {'nonexistent.txt' in storage}")
        
        # List files
        print(f"All files: {storage.list_files()}")
        
        # Delete a file
        del storage['test.txt']
        print(f"After deletion, 'test.txt' exists: {'test.txt' in storage}")
    """

Code Breakdown:

We've created several practical classes that demonstrate how dunder methods can be used in real-world applications:

1. APIResponse: Represents an API response with methods for string representation, truthiness checking, and data access:
   • __str__ and __repr__ for different string representations
   • __bool__ to determine success based on status code
   • __getitem__ for dictionary-like access to response data
2. ExponentialBackoff: A callable object implementing exponential backoff for retry logic:
   • __call__ for function-like behavior
   • Used in the retry_with_backoff decorator
3. ConfigDict: A configuration dictionary supporting both dictionary and dot notation access:
   • Container methods like __getitem__, __setitem__, etc.
   • Attribute access methods like __getattr__ and __setattr__
4. Cache: A simple caching system with expiring entries:
   • Container methods for dictionary-like access
   • Time-based expiration of cache entries
5. FileSystemStorage: A file storage system with context manager support:
   • __enter__ and __exit__ for context manager (with statement) support
   • Container methods for file access using dictionary notation

These examples demonstrate how dunder methods can be combined to create intuitive, Pythonic interfaces for complex functionality. By implementing the appropriate dunder methods, we can make our classes behave like built-in types, making them more familiar and easier to use for other developers.