Python Full Stack Web Developer Course

# Exercise 1: Name processing
def parse_name(full_name):
    # Split the name into parts
    parts = full_name.strip().split()
    
    # Handle edge cases
    if not parts:
        return ('', '', 0)
    elif len(parts) == 1:
        return (parts[0], '', len(parts[0]))
    
    # Standard case
    first_name = parts[0]
    last_name = parts[-1]
    total_length = len(full_name)
    
    return (first_name, last_name, total_length)

# Test cases
names = ["John Doe", "Jane Smith-Johnson", "Madonna", "  Bob  Jones  "]
for name in names:
    first, last, length = parse_name(name)
    print(f"Name: '{name}' -> First: '{first}', Last: '{last}', Length: {length}")


# Exercise 2: RGB to HSV conversion (simplified)
def rgb_to_hsv(rgb):
    r, g, b = rgb
    
    # Normalize RGB values to 0-1 range
    r, g, b = r / 255.0, g / 255.0, b / 255.0
    
    # Find max and min values
    max_val = max(r, g, b)
    min_val = min(r, g, b)
    delta = max_val - min_val
    
    # Calculate Hue (simplified)
    if delta == 0:
        h = 0  # No color, achromatic (gray)
    elif max_val == r:
        h = 60 * ((g - b) / delta % 6)
    elif max_val == g:
        h = 60 * ((b - r) / delta + 2)
    else:  # max_val == b
        h = 60 * ((r - g) / delta + 4)
    
    # Calculate Saturation
    s = 0 if max_val == 0 else delta / max_val
    
    # Value is the maximum RGB value
    v = max_val
    
    # Return HSV tuple (rounded values)
    return (round(h), round(s * 100), round(v * 100))

# Test cases
rgb_colors = [
    (255, 0, 0),    # Red
    (0, 255, 0),    # Green
    (0, 0, 255),    # Blue
    (255, 255, 0),  # Yellow
    (255, 0, 255),  # Magenta
    (0, 255, 255),  # Cyan
    (128, 128, 128) # Gray
]

for rgb in rgb_colors:
    hsv = rgb_to_hsv(rgb)
    print(f"RGB: {rgb} -> HSV: {hsv}")

from collections import namedtuple

# Create a User named tuple
User = namedtuple('User', ['id', 'username', 'email', 'name', 'active'])

# Create sample users
users = [
    User(1, 'jdoe', 'john@example.com', 'John Doe', True),
    User(2, 'asmith', 'alice@example.com', 'Alice Smith', True),
    User(3, 'bjones', 'bob@example.com', 'Bob Jones', False),
    User(4, 'cwilson', 'charlie@example.com', 'Charlie Wilson', True),
    User(5, 'dthomas', 'david@example.com', 'David Thomas', False)
]

# Function to filter active users
def get_active_users(user_list):
    return [user for user in user_list if user.active]

# Function to format user data as HTML table rows
def users_to_html_table(user_list):
    html = ["<table>", "  <tr><th>ID</th><th>Username</th><th>Email</th><th>Name</th><th>Status</th></tr>"]
    
    for user in user_list:
        status = "Active" if user.active else "Inactive"
        row = f"  <tr><td>{user.id}</td><td>{user.username}</td><td>{user.email}</td><td>{user.name}</td><td>{status}</td></tr>"
        html.append(row)
    
    html.append("</table>")
    return "\n".join(html)

# Test the functions
active_users = get_active_users(users)
print(f"Total users: {len(users)}")
print(f"Active users: {len(active_users)}")

# Print information about active users
for user in active_users:
    print(f"- {user.name} ({user.username}): {user.email}")

# Generate HTML table
html_table = users_to_html_table(users)
print("\nHTML Table:")
print(html_table)

# Simple web router using tuples

# Route handler functions
def home_handler(request):
    return "Home Page"

def about_handler(request):
    return "About Us Page"

def user_list_handler(request):
    return "User List Page"

def user_detail_handler(request, user_id):
    return f"User Detail Page for user {user_id}"

def create_user_handler(request):
    return "Create User Page (POST)"

def not_found_handler(request):
    return "404 - Page Not Found"

# Define routes as tuples: (path, method, handler, name)
routes = [
    ('/', 'GET', home_handler, 'home'),
    ('/about', 'GET', about_handler, 'about'),
    ('/users', 'GET', user_list_handler, 'user_list'),
    ('/users/<id>', 'GET', user_detail_handler, 'user_detail'),
    ('/users/new', 'POST', create_user_handler, 'create_user')
]

# Router function to match request to handler
def route_request(path, method):
    # First, look for exact matches
    for route_path, route_method, handler, _ in routes:
        if path == route_path and method == route_method:
            return handler, {}
    
    # Then, look for pattern matches (<id> parameters)
    for route_path, route_method, handler, _ in routes:
        if '<id>' in route_path and method == route_method:
            base_path = route_path.replace('/<id>', '')
            if path.startswith(base_path + '/'):
                # Extract the ID from the path
                param_id = path.replace(base_path + '/', '')
                if param_id.isdigit():  # Simple validation
                    return handler, {'user_id': param_id}
    
    # Return 404 handler if no match found
    return not_found_handler, {}

# Simulate some HTTP requests
requests = [
    ('/', 'GET'),
    ('/about', 'GET'),
    ('/users', 'GET'),
    ('/users/42', 'GET'),
    ('/users/new', 'POST'),
    ('/contact', 'GET'),  # Should return 404
    ('/users', 'POST'),   # Method not allowed
    ('/users/abc', 'GET') # Invalid ID format
]

# Process requests
for path, method in requests:
    print(f"\nRequest: {method} {path}")
    handler, params = route_request(path, method)
    
    if params:
        result = handler(None, **params)
    else:
        result = handler(None)
    
    print(f"Response: {result}")

# Utility function to generate URLs from route names
def url_for(name, **params):
    for path, _, _, route_name in routes:
        if route_name == name:
            # Replace parameters in the path
            result_path = path
            for param_name, param_value in params.items():
                result_path = result_path.replace(f"<{param_name}>", str(param_value))
            return result_path
    return None

# Test URL generation
print("\nURL Generation:")
print(f"Home URL: {url_for('home')}")
print(f"User detail URL: {url_for('user_detail', id=123)}")
print(f"Non-existent route: {url_for('contact')}")