13 - Python and SQLite Integration

# File: de-onboarding/sqlite_basics.py
from typing import List, Tuple  # For type annotations
import sqlite3  # For SQLite operations

def query_sales(db_path: str) -> List[Tuple[str, float, int]]:
    """Query all sales records from SQLite database."""
    print(f"Connecting to database: {db_path}")  # Debug
    conn = sqlite3.connect(db_path)  # Connect to database
    cursor = conn.cursor()  # Create cursor
    cursor.execute("SELECT product, price, quantity FROM sales")  # Execute query
    results: List[Tuple[str, float, int]] = cursor.fetchall()  # Fetch results
    print(f"Queried {len(results)} records")  # Debug
    conn.close()  # Close connection
    return results  # Return results

# Test
if __name__ == "__main__":
    results = query_sales("data/sales.db")
    print("Sales Records:", results)

# Expected Output (with sales.db from Appendix 1):
# Connecting to database: data/sales.db
# Queried 3 records
# Sales Records: [('Halal Laptop', 999.99, 2), ('Halal Mouse', 24.99, 10), ('Halal Keyboard', 49.99, 5)]

# File: de-onboarding/sqlite_insert.py
from typing import List, Tuple  # For type annotations
import sqlite3  # For SQLite operations

def insert_sale(db_path: str, sale: Tuple[str, float, int]) -> None:
    """Insert a sale record into SQLite database."""
    print(f"Inserting sale: {sale}")  # Debug
    conn = sqlite3.connect(db_path)  # Connect
    cursor = conn.cursor()  # Create cursor
    cursor.execute(
        "INSERT INTO sales (product, price, quantity) VALUES (?, ?, ?)",
        sale
    )  # Execute parameterized query
    conn.commit()  # Commit changes
    print("Sale inserted")  # Debug
    conn.close()  # Close connection

# Test
if __name__ == "__main__":
    sale = ("Halal Monitor", 199.99, 3)
    insert_sale("data/sales.db", sale)
    # Verify with: sqlite3 data/sales.db "SELECT * FROM sales;"

# File: de-onboarding/sqlite_benchmark.py
import sqlite3
import pandas as pd
import time
from typing import List, Tuple

def benchmark_sales(db_path: str, csv_path: str) -> None:
    """Benchmark SQLite query vs. Pandas filtering."""
    # SQLite query
    start_time = time.time()
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    cursor.execute("SELECT product, price, quantity FROM sales WHERE quantity > 5")
    sqlite_results: List[Tuple[str, float, int]] = cursor.fetchall()
    sqlite_time = time.time() - start_time
    conn.close()

    # Pandas filtering
    start_time = time.time()
    df = pd.read_csv(csv_path)
    pandas_results = df[df["quantity"] > 5][["product", "price", "quantity"]].values.tolist()
    pandas_time = time.time() - start_time

    print(f"SQLite Time: {sqlite_time:.4f} seconds, Records: {len(sqlite_results)}")
    print(f"Pandas Time: {pandas_time:.4f} seconds, Records: {len(pandas_results)}")

# Test
if __name__ == "__main__":
    benchmark_sales("data/sales.db", "data/sales.csv")

# Expected Output (times vary):
# SQLite Time: 0.0010 seconds, Records: 1
# Pandas Time: 0.0020 seconds, Records: 1

# File: de-onboarding/models.py
from pydantic import BaseModel, Field  # For Pydantic models
from typing import List  # For type annotations

class Sale(BaseModel):
    """Pydantic model for a sale record."""
    product: str = Field(..., min_length=1)  # Non-empty string
    price: float = Field(..., gt=0)  # Positive float
    quantity: int = Field(..., gt=0)  # Positive integer

class Config(BaseModel):
    """Pydantic model for configuration."""
    min_price: float = Field(..., ge=0)
    max_quantity: int = Field(..., gt=0)
    required_fields: List[str]
    product_prefix: str = Field(..., min_length=1)
    max_decimals: int = Field(..., ge=0)

# File: de-onboarding/validate_pydantic.py
from pydantic import ValidationError  # For error handling
from models import Sale  # Import Pydantic model
from typing import Optional  # For type annotations

def validate_sale(sale_dict: dict) -> Optional[Sale]:
    """Validate a sale dictionary using Pydantic."""
    try:
        sale = Sale(**sale_dict)  # Create Pydantic model
        print(f"Validated sale: {sale}")  # Debug
        return sale
    except ValidationError as e:
        print(f"Invalid sale: {sale_dict}, Error: {e}")  # Log error
        return None

# Test
if __name__ == "__main__":
    sale_dict = {"product": "Halal Laptop", "price": 999.99, "quantity": 2}
    sale = validate_sale(sale_dict)
    print("Result:", sale)
    invalid_sale = {"product": "", "price": -10.0, "quantity": 0}
    result = validate_sale(invalid_sale)
    print("Invalid Result:", result)

# Expected Output:
# Validated sale: product='Halal Laptop' price=999.99 quantity=2
# Result: product='Halal Laptop' price=999.99 quantity=2
# Invalid sale: {'product': '', 'price': -10.0, 'quantity': 0}, Error: 3 validation errors...
# Invalid Result: None

min_price: 10.0
max_quantity: 100
required_fields:
  - product
  - price
  - quantity
product_prefix: 'Halal'
max_decimals: 2

# File: de-onboarding/verify_setup.py
import os
import sys
import importlib.util
import pkg_resources

def verify_setup() -> None:
    """Verify setup for Chapter 13."""
    print("Verifying setup...")

    # Check Python version
    if sys.version_info < (3, 10):
        print("Error: Python 3.10+ required")
        return

    # Check required files
    required_files = ["data/sales.csv", "data/sample.csv", "data/config.yaml", "data/sales.db"]
    for file in required_files:
        if not os.path.exists(file):
            print(f"Error: Missing file {file}. See Appendix 1 for creation instructions.")
            return

    # Check required libraries and versions
    libraries = [
        ("pandas", "1.5.0"),
        ("pyyaml", "5.4.0"),
        ("pydantic", "2.0.0"),
        ("pytest", "7.0.0"),
        ("matplotlib", "3.5.0")
    ]
    for lib, min_version in libraries:
        if importlib.util.find_spec(lib) is None:
            print(f"Error: Library {lib} not installed. Run: pip install {lib}")
            return
        installed_version = pkg_resources.get_distribution(lib).version
        if pkg_resources.parse_version(installed_version) < pkg_resources.parse_version(min_version):
            print(f"Warning: {lib} version {installed_version} is outdated. Minimum required: {min_version}")

    print("Setup verified successfully!")

if __name__ == "__main__":
    verify_setup()

# File: de-onboarding/models.py
from pydantic import BaseModel, Field  # For Pydantic models
from typing import List  # For type annotations

class Sale(BaseModel):
    """Pydantic model for a sale record."""
    product: str = Field(..., min_length=1)  # Non-empty string
    price: float = Field(..., gt=0)  # Positive float
    quantity: int = Field(..., gt=0)  # Positive integer

class Config(BaseModel):
    """Pydantic model for configuration."""
    min_price: float = Field(..., ge=0)
    max_quantity: int = Field(..., gt=0)
    required_fields: List[str]
    product_prefix: str = Field(..., min_length=1)
    max_decimals: int = Field(..., ge=0)

# File: de-onboarding/utils.py (updated from Chapter 3)
from typing import Optional  # For type annotations

def is_numeric(s: str, max_decimals: int = 2) -> bool:
    """Check if string is a decimal number with up to max_decimals."""
    parts = s.split(".")  # Split on decimal point
    if len(parts) > 2:  # More than one decimal point
        return False
    if len(parts) == 2:  # Has decimal part
        if not parts[0].replace("-", "").isdigit() or not parts[1].isdigit():
            return False  # Invalid digits
        return len(parts[1]) <= max_decimals  # Check decimal places
    return parts[0].replace("-", "").isdigit()  # Integer case

def clean_string(s: str) -> str:
    """Strip whitespace from string."""
    return s.strip()

def is_numeric_value(x: object) -> bool:
    """Check if value is numeric."""
    return isinstance(x, (int, float))

def has_valid_decimals(x: object, max_decimals: int) -> bool:
    """Check if value has valid decimal places."""
    return is_numeric(str(x), max_decimals)

def apply_valid_decimals(x: object, max_decimals: int) -> bool:
    """Apply has_valid_decimals to a value."""
    return has_valid_decimals(x, max_decimals)

def is_integer(x: object) -> bool:
    """Check if value is an integer."""
    return isinstance(x, int) or (isinstance(x, str) and x.isdigit())

# File: de-onboarding/database.py
from typing import List, Tuple, Dict  # For type annotations
import sqlite3  # For SQLite operations

class Database:
    """Type-safe SQLite database operations."""
    def __init__(self, db_path: str):
        self.db_path: str = db_path

    def insert_sale(self, sale: Tuple[str, float, int]) -> None:
        """Insert a sale record."""
        print(f"Inserting sale: {sale}")  # Debug
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute(
            "INSERT INTO sales (product, price, quantity) VALUES (?, ?, ?)",
            sale
        )
        conn.commit()
        conn.close()
        print("Sale inserted")  # Debug

    def update_sale(self, product: str, new_quantity: int) -> None:
        """Update quantity for a product."""
        print(f"Updating sale: {product}, new_quantity={new_quantity}")  # Debug
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute(
            "UPDATE sales SET quantity = ? WHERE product = ?",
            (new_quantity, product)
        )
        conn.commit()
        conn.close()
        print("Sale updated")  # Debug

    def query_sales(self) -> List[Tuple[str, float, int]]:
        """Query all sales records."""
        print(f"Querying sales from: {self.db_path}")  # Debug
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute("SELECT product, price, quantity FROM sales")
        results: List[Tuple[str, float, int]] = cursor.fetchall()
        conn.close()
        print(f"Queried {len(results)} records")  # Debug
        return results

    def query_total_sales(self) -> float:
        """Query total sales amount."""
        print("Querying total sales")  # Debug
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute("SELECT SUM(price * quantity) FROM sales")
        total: float = cursor.fetchone()[0] or 0.0
        conn.close()
        print(f"Total sales: {total}")  # Debug
        return total

    def query_top_products(self, limit: int = 3) -> Dict[str, float]:
        """Query top products by sales."""
        print(f"Querying top {limit} products")  # Debug
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute("""
            SELECT product, SUM(price * quantity) as amount
            FROM sales
            GROUP BY product
            ORDER BY amount DESC
            LIMIT ?
        """, (limit,))
        results = cursor.fetchall()
        conn.close()
        top_products: Dict[str, float] = {row[0]: row[1] for row in results}
        print(f"Top products: {top_products}")  # Debug
        return top_products

# File: de-onboarding/data_loader.py
from typing import Tuple, Dict, List, Optional  # For type annotations
import pandas as pd  # For CSV loading
import yaml  # For YAML parsing
import json  # For JSON export
from pydantic import ValidationError  # For Pydantic errors
from models import Sale, Config  # Import Pydantic models
from database import Database  # Import database operations
import utils  # Import utilities

def read_config(config_path: str) -> Config:
    """Read and validate YAML configuration."""
    print(f"Opening config: {config_path}")  # Debug
    with open(config_path, "r") as file:
        config_data = yaml.safe_load(file)
    config = Config(**config_data)  # Validate with Pydantic
    print(f"Loaded config: {config}")  # Debug
    return config

def load_and_validate_sales(csv_path: str, config: Config) -> Tuple[List[Sale], int, int, List[str]]:
    """Load and validate sales CSV, tracking invalid records."""
    print(f"Loading CSV: {csv_path}")  # Debug
    df = pd.read_csv(csv_path)
    print("Initial DataFrame:")  # Debug
    print(df.head())

    # Validate columns
    required_fields = config.required_fields
    missing_fields = [f for f in required_fields if f not in df.columns]
    if missing_fields:
        print(f"Missing columns: {missing_fields}")  # Log
        return [], 0, len(df), [f"Missing columns: {missing_fields}"]

    # Clean and filter DataFrame
    df = df.dropna(subset=["product"])
    df = df[df["product"].str.startswith(config.product_prefix)]
    df = df[df["quantity"].apply(utils.is_integer)]
    df["quantity"] = df["quantity"].astype(int)
    df = df[df["quantity"] <= config.max_quantity]
    df = df[df["price"].apply(utils.is_numeric_value)]
    df = df[df["price"] > 0]
    df = df[df["price"] >= config.min_price]
    df = df[df["price"].apply(lambda x: utils.apply_valid_decimals(x, config.max_decimals))]

    valid_sales: List[Sale] = []
    invalid_reasons: List[str] = []
    for _, row in df.iterrows():
        sale_dict = {
            "product": row["product"],
            "price": float(row["price"]),
            "quantity": int(row["quantity"])
        }
        try:
            sale = Sale(**sale_dict)
            valid_sales.append(sale)
        except ValidationError as e:
            print(f"Invalid sale: {sale_dict}, Error: {e}")  # Log
            invalid_reasons.append(f"Invalid sale {sale_dict}: {str(e)}")

    total_records = len(df)
    print("Validated Sales:", len(valid_sales))  # Debug
    return valid_sales, len(valid_sales), total_records, invalid_reasons

def process_sales(sales: List[Sale], db: Database, update_existing: bool = True) -> Tuple[Dict, int]:
    """Process, insert, and optionally update sales in SQLite."""
    valid_sales = 0
    for sale in sales:
        if update_existing:
            existing_sales = db.query_sales()
            existing_products = [s[0] for s in existing_sales]
            if sale.product in existing_products:
                db.update_sale(sale.product, sale.quantity)
            else:
                db.insert_sale((sale.product, sale.price, sale.quantity))
        else:
            db.insert_sale((sale.product, sale.price, sale.quantity))
        valid_sales += 1

    total_sales = db.query_total_sales()
    top_products = db.query_top_products()
    results = {
        "total_sales": float(total_sales),
        "unique_products": list(set(sale.product for sale in sales)),
        "top_products": top_products
    }
    print(f"Processed {valid_sales} sales")  # Debug
    return results, valid_sales

def export_results(results: Dict, json_path: str) -> None:
    """Export results to JSON."""
    print(f"Writing to: {json_path}")  # Debug
    with open(json_path, "w") as file:
        json.dump(results, file, indent=2)
    print(f"Exported results to {json_path}")  # Debug

def main(csv_path: str = "data/sales.csv", update_existing: bool = True) -> None:
    """Main function to load and process sales data."""
    config_path = "data/config.yaml"
    db_path = "data/sales.db"
    json_path = "data/sales_report.json"

    config = read_config(config_path)
    sales, valid_sales, total_records, invalid_reasons = load_and_validate_sales(csv_path, config)
    db = Database(db_path)
    results, valid_sales = process_sales(sales, db, update_existing)
    export_results(results, json_path)

    print("\nSales Report:")
    print(f"Total Records Processed: {total_records}")
    print(f"Valid Sales: {valid_sales}")
    print(f"Invalid Sales: {total_records - valid_sales}")
    if invalid_reasons:
        print(f"Invalid records: {len(invalid_reasons)}")
        for reason in invalid_reasons:
            print(f" - {reason}")
    print(f"Total Sales: ${round(results['total_sales'], 2)}")
    print(f"Unique Products: {results['unique_products']}")
    print(f"Top Products: {results['top_products']}")
    print("Processing completed")

if __name__ == "__main__":
    main()

# File: de-onboarding/tests/test_data_loader.py
from typing import List  # For type annotations
import pytest  # For testing
from data_loader import read_config, load_and_validate_sales, process_sales, Database
from models import Config, Sale  # Import Pydantic models
import sqlite3  # For SQLite operations
import os  # For file operations

@pytest.fixture
def setup_db(tmp_path):
    """Create a temporary SQLite database."""
    db_path = tmp_path / "test.db"
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    cursor.execute("""
        CREATE TABLE sales (
            product TEXT,
            price REAL,
            quantity INTEGER
        )
    """)
    conn.commit()
    conn.close()
    return str(db_path)

def test_read_config():
    """Test reading and validating config."""
    config = read_config("data/config.yaml")
    assert isinstance(config, Config)
    assert config.min_price == 10.0
    assert config.max_quantity == 100
    assert config.product_prefix == "Halal"

def test_load_and_validate_sales():
    """Test loading and validating sales CSV."""
    config = read_config("data/config.yaml")
    sales, valid_sales, total_records, invalid_reasons = load_and_validate_sales("data/sales.csv", config)
    assert valid_sales == 3
    assert total_records == 3
    assert len(invalid_reasons) == 0
    assert all(isinstance(sale, Sale) for sale in sales)
    assert sales[0].product == "Halal Laptop"

def test_load_empty_csv():
    """Test loading empty CSV."""
    config = read_config("data/config.yaml")
    sales, valid_sales, total_records, invalid_reasons = load_and_validate_sales("data/empty.csv", config)
    assert sales == []
    assert valid_sales == 0
    assert total_records == 0
    assert len(invalid_reasons) == 0

def test_load_invalid_csv():
    """Test loading CSV with invalid headers."""
    config = read_config("data/config.yaml")
    sales, valid_sales, total_records, invalid_reasons = load_and_validate_sales("data/invalid.csv", config)
    assert sales == []
    assert valid_sales == 0
    assert total_records == 1
    assert len(invalid_reasons) == 1
    assert "Missing columns" in invalid_reasons[0]

def test_load_malformed_csv():
    """Test loading CSV with malformed data."""
    config = read_config("data/config.yaml")
    sales, valid_sales, total_records, invalid_reasons = load_and_validate_sales("data/malformed.csv", config)
    assert valid_sales == 1
    assert total_records == 1
    assert len(invalid_reasons) == 0
    assert sales[0].product == "Halal Mouse"

def test_process_sales(setup_db):
    """Test processing and querying sales."""
    db = Database(setup_db)
    sales = [
        Sale(product="Halal Laptop", price=999.99, quantity=2),
        Sale(product="Halal Mouse", price=24.99, quantity=10)
    ]
    results, valid_sales = process_sales(sales, db, update_existing=False)
    assert valid_sales == 2
    assert results["total_sales"] == 2249.88
    assert len(results["unique_products"]) == 2
    assert results["top_products"]["Halal Laptop"] == 1999.98

def test_update_sale(setup_db):
    """Test updating a sale's quantity."""
    db = Database(setup_db)
    db.insert_sale(("Halal Laptop", 999.99, 2))
    db.update_sale("Halal Laptop", 5)
    sales = db.query_sales()
    assert sales[0][2] == 5  # Verify updated quantity

{
  "total_sales": 2499.83,
  "unique_products": ["Halal Laptop", "Halal Mouse", "Halal Keyboard"],
  "top_products": {
    "Halal Laptop": 1999.98,
    "Halal Mouse": 249.9,
    "Halal Keyboard": 249.95
  }
}

db_path = "data/sales.db"
min_quantity = 5

sale_dict = {"product": "Halal Laptop", "price": 999.99, "quantity": 2}

sales = [("Halal Monitor", 199.99, 3), ("Halal Webcam", 59.99, 4)]

import sqlite3
def insert_sale(db_path, sale):
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    cursor.execute("INSERT INTO sales VALUES (?, ?, ?)", sale)  # Bug: Missing column names
    conn.commit()
    conn.close()

db_path = "data/sales.db"
csv_path = "data/sales.csv"

from pydantic import ValidationError
from models import Sale

def validate_sale(sale_dict):
    try:
        sale = Sale(**sale_dict)
        return sale
    except ValidationError as e:
        print(f"Invalid sale: {sale_dict}, Error: {e}")
        return None

sale_dict = {"product": "Halal Laptop", "price": -999.99, "quantity": 2}  # Bug: Negative price
result = validate_sale(sale_dict)
print("Result:", result)

db_path = "data/sales.db"
plot_path = "ex8_plot.png"

config_path = "data/invalid_config.yaml"

min_price: -10.0
max_quantity: 100
required_fields:
  - product
  - price
  - quantity
product_prefix: 'Halal'
max_decimals: 2

from typing import List, Tuple
import sqlite3

def query_min_quantity(db_path: str, min_quantity: int) -> List[Tuple[str, float, int]]:
    """Query sales with minimum quantity."""
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    cursor.execute("SELECT product, price, quantity FROM sales WHERE quantity >= ?", (min_quantity,))
    results: List[Tuple[str, float, int]] = cursor.fetchall()
    conn.close()
    return results

# Test
print(query_min_quantity("data/sales.db", 5))

from pydantic import ValidationError
from models import Sale
from typing import Optional

def validate_sale(sale_dict: dict) -> Optional[Sale]:
    """Validate a sale dictionary."""
    try:
        sale = Sale(**sale_dict)
        return sale
    except ValidationError:
        return None

# Test
print(validate_sale({"product": "Halal Laptop", "price": 999.99, "quantity": 2}))

from typing import List, Tuple
import sqlite3

def insert_sales(db_path: str, sales: List[Tuple[str, float, int]]) -> None:
    """Insert multiple sales."""
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    for sale in sales:
        cursor.execute("INSERT INTO sales (product, price, quantity) VALUES (?, ?, ?)", sale)
    conn.commit()
    conn.close()
    print(f"Inserted {len(sales)} sales")

# Test
insert_sales("data/sales.db", [("Halal Monitor", 199.99, 3), ("Halal Webcam", 59.99, 4)])

import pytest
import sqlite3
from database import Database

@pytest.fixture
def setup_db(tmp_path):
    db_path = tmp_path / "test.db"
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    cursor.execute("CREATE TABLE sales (product TEXT, price REAL, quantity INTEGER)")
    cursor.executemany(
        "INSERT INTO sales (product, price, quantity) VALUES (?, ?, ?)",
        [("Halal Laptop", 999.99, 2), ("Halal Mouse", 24.99, 10)]
    )
    conn.commit()
    conn.close()
    return str(db_path)

def test_total_sales(setup_db):
    db = Database(setup_db)
    total = db.query_total_sales()
    assert total == 2249.88

import sqlite3

def insert_sale(db_path: str, sale: Tuple[str, float, int]) -> None:
    """Insert a sale record."""
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    cursor.execute("INSERT INTO sales (product, price, quantity) VALUES (?, ?, ?)", sale)  # Fix: Specify columns
    conn.commit()
    conn.close()
    print("Sale inserted")

# Test
insert_sale("data/sales.db", ("Halal Monitor", 199.99, 3))

def compare_storage(db_path: str, csv_path: str, output_path: str) -> None:
    """Compare SQLite and Pandas storage efficiency."""
    explanation = (
        "SQLite’s B-tree storage enables efficient O(log n) indexed queries and compact disk "
        "storage (~1MB for 10,000 rows), ideal for persistent data in Hijra Group’s pipelines. "
        "Pandas’ column-oriented memory, using NumPy arrays, supports fast O(1) column access but "
        "requires ~24MB for 1 million rows in memory, better for in-memory analytics."
    )
    print(explanation)
    with open(output_path, "w") as file:
        file.write(explanation)

# Test
compare_storage("data/sales.db", "data/sales.csv", "ex6_concepts.txt")

from pydantic import ValidationError
from models import Sale
from typing import Optional

def validate_sale(sale_dict: dict) -> Optional[Sale]:
    """Validate a sale dictionary."""
    try:
        sale = Sale(**sale_dict)
        print(f"Validated sale: {sale}")
        return sale
    except ValidationError as e:
        print(f"Invalid sale: {sale_dict}, Error: {e}")
        print(f"Failing field: {e.errors()[0]['loc'][0]}")
        return None

# Test
sale_dict = {"product": "Halal Laptop", "price": 999.99, "quantity": 2}  # Fix: Positive price
result = validate_sale(sale_dict)
print("Result:", result)

from typing import Dict
import sqlite3
import matplotlib.pyplot as plt

def visualize_sales(db_path: str, plot_path: str) -> None:
    """Query sales and create a bar plot of total sales by product."""
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    cursor.execute("SELECT product, SUM(price * quantity) as amount FROM sales GROUP BY product")
    results = cursor.fetchall()
    conn.close()

    if not results:
        print("No data to plot")
        return

    products, amounts = zip(*results)
    plt.figure(figsize=(8, 6))
    plt.bar(products, amounts)
    plt.title("Sales by Product")
    plt.xlabel("Product")
    plt.ylabel("Sales Amount ($)")
    plt.xticks(rotation=45)
    plt.grid(True)
    plt.tight_layout()
    plt.savefig(plot_path, dpi=100)
    plt.close()
    print(f"Plot saved to {plot_path}")

# Test
visualize_sales("data/sales.db", "ex8_plot.png")

from pydantic import ValidationError
from models import Config
from typing import Optional
import yaml

def validate_config(config_path: str) -> Optional[Config]:
    """Validate a configuration file using Pydantic."""
    print(f"Opening config: {config_path}")  # Debug
    with open(config_path, "r") as file:
        config_data = yaml.safe_load(file)
    try:
        config = Config(**config_data)
        print(f"Validated config: {config}")
        return config
    except ValidationError as e:
        print(f"Invalid config: {config_data}, Error: {e}")
        print(f"Failing field: {e.errors()[0]['loc'][0]}")
        return None

# Test
result = validate_config("data/invalid_config.yaml")
print("Result:", result)