Python Full Stack Web Developer Course

# E-commerce catalog data
catalog = {
    "store_name": "TechShop",
    "categories": [
        {
            "id": "electronics",
            "name": "Electronics",
            "products": [
                {
                    "id": "e1",
                    "name": "Smartphone",
                    "price": 699.99,
                    "stock": 15,
                    "attributes": {
                        "brand": "TechBrand",
                        "model": "X100",
                        "features": ["5G", "Dual Camera", "Fast Charging"]
                    }
                },
                {
                    "id": "e2",
                    "name": "Laptop",
                    "price": 1299.99,
                    "stock": 8,
                    "attributes": {
                        "brand": "ComputeCorp",
                        "model": "ProBook",
                        "features": ["16GB RAM", "512GB SSD", "14-inch Display"]
                    }
                },
                {
                    "id": "e3",
                    "name": "Headphones",
                    "price": 149.99,
                    "stock": 3,
                    "attributes": {
                        "brand": "AudioPlus",
                        "model": "NoiseCancel",
                        "features": ["Noise Cancellation", "Bluetooth", "40h Battery"]
                    }
                }
            ]
        },
        {
            "id": "home",
            "name": "Home & Kitchen",
            "products": [
                {
                    "id": "h1",
                    "name": "Coffee Maker",
                    "price": 79.99,
                    "stock": 12,
                    "attributes": {
                        "brand": "BrewMaster",
                        "model": "CM5000",
                        "features": ["12-cup", "Programmable", "Auto Shutoff"]
                    }
                },
                {
                    "id": "h2",
                    "name": "Stand Mixer",
                    "price": 249.99,
                    "stock": 5,
                    "attributes": {
                        "brand": "KitchenGuru",
                        "model": "MixPro",
                        "features": ["5 Speeds", "5L Bowl", "Multiple Attachments"]
                    }
                },
                {
                    "id": "h3",
                    "name": "Toaster",
                    "price": 29.99,
                    "stock": 2,
                    "attributes": {
                        "brand": "BrewMaster",
                        "model": "T2000",
                        "features": ["2-Slice", "Bagel Setting", "Defrost"]
                    }
                }
            ]
        }
    ]
}

# 1. Extract all products with price greater than $50
def find_expensive_products(catalog_data, price_threshold=50.0):
    """Find all products with price greater than the threshold."""
    expensive_products = []
    
    for category in catalog_data["categories"]:
        for product in category["products"]:
            if product["price"] > price_threshold:
                # Add category information to each product
                product_with_category = product.copy()
                product_with_category["category"] = category["name"]
                expensive_products.append(product_with_category)
    
    return expensive_products

# 2. Calculate total inventory value by category
def calculate_inventory_value_by_category(catalog_data):
    """Calculate the total value of inventory for each category."""
    category_values = {}
    
    for category in catalog_data["categories"]:
        category_total = 0
        for product in category["products"]:
            product_value = product["price"] * product["stock"]
            category_total += product_value
        
        category_values[category["name"]] = category_total
    
    return category_values

# 3. Find products that are low in stock (less than 5 units)
def find_low_stock_products(catalog_data, threshold=5):
    """Find products with stock below the threshold."""
    low_stock = []
    
    for category in catalog_data["categories"]:
        for product in category["products"]:
            if product["stock"] < threshold:
                low_stock.append({
                    "id": product["id"],
                    "name": product["name"],
                    "category": category["name"],
                    "stock": product["stock"]
                })
    
    return low_stock

# 4. Transform the data to a different nested structure
def transform_catalog_structure(catalog_data):
    """
    Transform catalog structure to:
    {
        "store_name": "...",
        "products_by_brand": {
            "brand1": [product1, product2, ...],
            "brand2": [product3, ...]
        },
        "products_by_id": {
            "id1": product1,
            "id2": product2,
            ...
        }
    }
    """
    transformed = {
        "store_name": catalog_data["store_name"],
        "products_by_brand": {},
        "products_by_id": {}
    }
    
    for category in catalog_data["categories"]:
        for product in category["products"]:
            # Add category info to product
            product_with_category = product.copy()
            product_with_category["category"] = category["name"]
            
            # Add to products_by_id
            transformed["products_by_id"][product["id"]] = product_with_category
            
            # Add to products_by_brand
            brand = product["attributes"]["brand"]
            if brand not in transformed["products_by_brand"]:
                transformed["products_by_brand"][brand] = []
            
            transformed["products_by_brand"][brand].append(product_with_category)
    
    return transformed

# Test the functions
expensive_products = find_expensive_products(catalog)
print("\nProducts over $50:")
for product in expensive_products:
    print(f"  {product['name']} (${product['price']:.2f}) - {product['category']}")

inventory_values = calculate_inventory_value_by_category(catalog)
print("\nInventory value by category:")
for category, value in inventory_values.items():
    print(f"  {category}: ${value:.2f}")

low_stock = find_low_stock_products(catalog)
print("\nLow stock products:")
for product in low_stock:
    print(f"  {product['name']} ({product['category']}): {product['stock']} units")

transformed = transform_catalog_structure(catalog)
print("\nTransformed structure:")
print(f"  Store name: {transformed['store_name']}")
print(f"  Number of brands: {len(transformed['products_by_brand'])}")
print(f"  Number of products: {len(transformed['products_by_id'])}")
print("\nProducts by brand:")
for brand, products in transformed['products_by_brand'].items():
    print(f"  {brand}: {', '.join(p['name'] for p in products)}")

# Demonstrate access by ID
product_id = "h2"
product = transformed['products_by_id'].get(product_id)
if product:
    print(f"\nProduct {product_id} details:")
    print(f"  Name: {product['name']}")
    print(f"  Price: ${product['price']:.2f}")
    print(f"  Category: {product['category']}")
    print(f"  Features: {', '.join(product['attributes']['features'])}")

import json
import os
import re

class ConfigurationManager:
    """Configuration management system."""
    
    def __init__(self, default_config=None):
        """Initialize with optional default configuration."""
        self.config = default_config or {}
        self.schema = None
    
    def load_from_file(self, file_path):
        """Load configuration from a JSON file."""
        try:
            with open(file_path, 'r') as f:
                file_config = json.load(f)
            
            # Merge with existing config
            self.merge_config(file_config)
            return True
        except (json.JSONDecodeError, FileNotFoundError) as e:
            print(f"Error loading config from {file_path}: {e}")
            return False
    
    def load_from_env(self, prefix="APP_"):
        """
        Load configuration from environment variables.
        
        Environment variables should be in the format:
        PREFIX_SECTION_SUBSECTION_KEY=value
        """
        env_config = {}
        pattern = re.compile(f"^{prefix}(.+)$")
        
        for key, value in os.environ.items():
            match = pattern.match(key)
            if match:
                # Remove prefix and split into parts
                config_key = match.group(1)
                parts = config_key.lower().split('_')
                
                # Navigate/create the nested structure
                current = env_config
                for part in parts[:-1]:
                    if part not in current:
                        current[part] = {}
                    current = current[part]
                
                # Set the value, converting to appropriate type
                final_key = parts[-1]
                if value.lower() == 'true':
                    current[final_key] = True
                elif value.lower() == 'false':
                    current[final_key] = False
                elif value.isdigit():
                    current[final_key] = int(value)
                elif re.match(r'^-?\d+(\.\d+)?$', value):
                    current[final_key] = float(value)
                else:
                    current[final_key] = value
        
        # Merge with existing config
        self.merge_config(env_config)
        return env_config
    
    def merge_config(self, new_config):
        """Merge a new configuration with the existing one."""
        self.config = self._deep_merge(self.config, new_config)
    
    def _deep_merge(self, base, overlay):
        """
        Recursively merge two dictionaries.
        
        Args:
            base: The base dictionary
            overlay: The dictionary to overlay on top of base
            
        Returns:
            A new dictionary with the merged values
        """
        result = base.copy()
        
        for key, value in overlay.items():
            if isinstance(value, dict) and key in result and isinstance(result[key], dict):
                # Recursively merge dictionaries
                result[key] = self._deep_merge(result[key], value)
            else:
                # Override or add value
                result[key] = value
        
        return result
    
    def set_schema(self, schema):
        """Set the schema for validation."""
        self.schema = schema
    
    def validate(self):
        """Validate the configuration against the schema."""
        if not self.schema:
            print("No schema set for validation")
            return True
            
        validator = SchemaValidator(self.schema)
        errors = validator.validate(self.config)
        
        if errors:
            print("Configuration validation errors:")
            for error in validator.format_errors(errors):
                print(f"  {error}")
            return False
        
        return True
    
    def get(self, path=None, default=None):
        """
        Get a configuration value using dot notation.
        
        Args:
            path: Dot-separated path to the value (e.g., "database.host")
            default: Default value if the path doesn't exist
            
        Returns:
            The value at the specified path or the default
        """
        if not path:
            return self.config
        
        parts = path.split('.')
        current = self.config
        
        for part in parts:
            if isinstance(current, dict) and part in current:
                current = current[part]
            else:
                return default
        
        return current
    
    def set(self, path, value):
        """
        Set a configuration value using dot notation.
        
        Args:
            path: Dot-separated path to the value (e.g., "database.host")
            value: The value to set
        """
        parts = path.split('.')
        current = self.config
        
        # Navigate to the parent object
        for part in parts[:-1]:
            if part not in current:
                current[part] = {}
            current = current[part]
        
        # Set the value
        current[parts[-1]] = value
        def save_to_file(self, file_path):
        """Save the configuration to a JSON file."""
        try:
            # Create directory if it doesn't exist
            os.makedirs(os.path.dirname(file_path), exist_ok=True)
            
            # Write to file
            with open(file_path, 'w') as f:
                json.dump(self.config, f, indent=2)
            return True
        except Exception as e:
            print(f"Error saving config to {file_path}: {e}")
            return False

# Schema validator class
class SchemaValidator:
    """Schema validator for configuration data."""
    
    def __init__(self, schema):
        """Initialize with a schema definition."""
        self.schema = schema
    
    def validate(self, data, schema=None, path=None):
        """Validate data against the schema."""
        if schema is None:
            schema = self.schema
        
        if path is None:
            path = []
        
        errors = []
        
        # Check type
        if "type" in schema:
            expected_type = schema["type"]
            if expected_type == "object":
                if not isinstance(data, dict):
                    errors.append((path, f"Expected object, got {type(data).__name__}"))
                    return errors
            elif expected_type == "array":
                if not isinstance(data, list):
                    errors.append((path, f"Expected array, got {type(data).__name__}"))
                    return errors
            elif expected_type == "string":
                if not isinstance(data, str):
                    errors.append((path, f"Expected string, got {type(data).__name__}"))
            elif expected_type == "number":
                if not isinstance(data, (int, float)):
                    errors.append((path, f"Expected number, got {type(data).__name__}"))
            elif expected_type == "boolean":
                if not isinstance(data, bool):
                    errors.append((path, f"Expected boolean, got {type(data).__name__}"))
        
        # Check required fields
        if "required" in schema and isinstance(data, dict):
            for field in schema["required"]:
                if field not in data:
                    errors.append((path, f"Missing required field: {field}"))
        
        # Check properties
        if "properties" in schema and isinstance(data, dict):
            for prop, prop_schema in schema["properties"].items():
                if prop in data:
                    prop_path = path + [prop]
                    errors.extend(self.validate(data[prop], prop_schema, prop_path))
        
        # Check items in arrays
        if "items" in schema and isinstance(data, list):
            for i, item in enumerate(data):
                item_path = path + [i]
                errors.extend(self.validate(item, schema["items"], item_path))
        
        return errors
    
    def format_errors(self, errors):
        """Format validation errors for human readability."""
        result = []
        for path, message in errors:
            path_str = '.'.join(str(p) for p in path) if path else "root"
            result.append(f"{path_str}: {message}")
        return result

# Test the configuration manager
def test_config_manager():
    """Test the configuration management system."""
    # Define default configuration
    default_config = {
        "app": {
            "name": "MyApp",
            "debug": False,
            "port": 3000
        },
        "database": {
            "host": "localhost",
            "port": 5432,
            "name": "myapp",
            "user": "admin"
        },
        "logging": {
            "level": "INFO",
            "file": "/var/log/myapp.log"
        }
    }
    
    # Define schema
    schema = {
        "type": "object",
        "required": ["app", "database"],
        "properties": {
            "app": {
                "type": "object",
                "required": ["name", "port"],
                "properties": {
                    "name": {"type": "string"},
                    "debug": {"type": "boolean"},
                    "port": {"type": "number"}
                }
            },
            "database": {
                "type": "object",
                "required": ["host", "name", "user"],
                "properties": {
                    "host": {"type": "string"},
                    "port": {"type": "number"},
                    "name": {"type": "string"},
                    "user": {"type": "string"},
                    "password": {"type": "string"}
                }
            },
            "logging": {
                "type": "object",
                "properties": {
                    "level": {"type": "string"},
                    "file": {"type": "string"}
                }
            }
        }
    }
    
    # Create configuration manager
    config_manager = ConfigurationManager(default_config)
    config_manager.set_schema(schema)
    
    # Override with file configuration
    file_config = {
        "app": {
            "debug": True
        },
        "database": {
            "password": "secret"
        }
    }
    
    # Simulate loading from file
    config_manager.merge_config(file_config)
    
    # Validate configuration
    if config_manager.validate():
        print("Configuration is valid")
    else:
        print("Configuration is invalid")
    
    # Access configuration
    print(f"App name: {config_manager.get('app.name')}")
    print(f"Debug mode: {config_manager.get('app.debug')}")
    print(f"Database connection: {config_manager.get('database.user')}@{config_manager.get('database.host')}:{config_manager.get('database.port')}/{config_manager.get('database.name')}")
    
    # Modify configuration
    config_manager.set("app.port", 8080)
    config_manager.set("logging.level", "DEBUG")
    
    # Check updates
    print(f"Updated port: {config_manager.get('app.port')}")
    print(f"Updated log level: {config_manager.get('logging.level')}")
    
    # Save to file (commented out to avoid filesystem changes)
    # config_manager.save_to_file("config.json")

# Run the test
test_config_manager()