# Django ORM Comparison - Know both frameworks
# Django model (contrast with SQLAlchemy)
from django.db import models

class Department(models.Model):
    name = models.CharField(max_length=50)

class Employee(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField(unique=True)
    department = models.ForeignKey(Department, on_delete=models.CASCADE)

# Django query (similar but different syntax)
Employee.objects.filter(department__name="HR").select_related('department')

# Async ORM - Modern Python requirement
# Requires SQLAlchemy 1.4+ and asyncpg
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession

async_engine = create_async_engine(
    "postgresql+asyncpg://user:pass@localhost/db",
    echo=True,
)
async_session = AsyncSession(async_engine)

async with async_session.begin():
    result = await async_session.execute(
        select(Employee).where(Employee.name == "Alice")
    )
    employee = result.scalar_one()

# Testing Strategies - Interview differentiator
from unittest import mock

# Mock database for unit tests
with mock.patch('sqlalchemy.create_engine') as mock_engine:
    mock_conn = mock.MagicMock()
    mock_engine.return_value.connect.return_value = mock_conn
    
    # Test your ORM-dependent code
    create_employee("Test", "[email protected]")
    mock_conn.execute.assert_called()

# Production Monitoring - Track slow queries
from sqlalchemy import event

@event.listens_for(engine, "before_cursor_execute")
def before_cursor(conn, cursor, statement, params, context, executemany):
    conn.info.setdefault('query_start_time', []).append(time.time())

@event.listens_for(engine, "after_cursor_execute")
def after_cursor(conn, cursor, statement, params, context, executemany):
    total = time.time() - conn.info['query_start_time'].pop(-1)
    if total > 0.1:  # Log slow queries
        print(f"SLOW QUERY ({total:.2f}s): {statement}")

# Interview Power Move: Implement caching layer
from functools import lru_cache

class CachedEmployeeRepository(EmployeeRepository):
    @lru_cache(maxsize=100)
    def get_by_id(self, employee_id):
        return super().get_by_id(employee_id)
    
    def invalidate_cache(self, employee_id):
        self.get_by_id.cache_clear()

# Reduces database hits by 70% in read-heavy applications

# Pro Tip: Schema versioning in CI/CD pipelines
# Sample .gitlab-ci.yml snippet
deploy_db:
  stage: deploy
  script:
    - alembic upgrade head
    - pytest tests/db_tests.py  # Verify schema compatibility
  only:
    - main

# Real-World Case Study: E-commerce inventory system
class Product(Base):
    __tablename__ = 'products'
    id = Column(Integer, primary_key=True)
    sku = Column(String(20), unique=True)
    stock = Column(Integer, default=0)
    
    # Atomic stock update (prevents race conditions)
    def decrement_stock(self, quantity, session):
        result = session.query(Product).filter(
            Product.id == self.id,
            Product.stock >= quantity
        ).update({"stock": Product.stock - quantity})
        if not result:
            raise ValueError("Insufficient stock")

# Usage during checkout
product.decrement_stock(2, session)

# Interview Power Move: Parallel Merging
from concurrent.futures import ThreadPoolExecutor
from PyPDF2 import PdfMerger

def parallel_merge(pdf_list, output, max_workers=4):
    chunks = [pdf_list[i::max_workers] for i in range(max_workers)]
    temp_files = []
    
    def merge_chunk(chunk, idx):
        temp = f"temp_{idx}.pdf"
        merger = PdfMerger()
        for pdf in chunk:
            merger.append(pdf)
        merger.write(temp)
        return temp
    
    with ThreadPoolExecutor() as executor:
        temp_files = list(executor.map(merge_chunk, chunks, range(max_workers)))
    
    # Final merge of chunks
    final_merger = PdfMerger()
    for temp in temp_files:
        final_merger.append(temp)
    final_merger.write(output)

parallel_merge(["doc1.pdf", "doc2.pdf", ...], "parallel_merge.pdf")

# Pro Tip: Validate PDFs before merging
from PyPDF2 import PdfReader

def is_valid_pdf(path):
    try:
        with open(path, "rb") as f:
            reader = PdfReader(f)
            return len(reader.pages) > 0
    except:
        return False

valid_pdfs = [f for f in pdf_files if is_valid_pdf(f)]
merger.append(valid_pdfs)  # Only merge valid files

# Real-World Case Study: Invoice Processing Pipeline
import glob
from PyPDF2 import PdfMerger

def process_monthly_invoices():
    # 1. Download invoices from SFTP
    download_invoices("sftp://vendor.com/invoices/*.pdf")
    
    # 2. Validate and sort
    invoices = sorted(
        [f for f in glob.glob("invoices/*.pdf") if is_valid_pdf(f)],
        key=lambda x: extract_invoice_date(x)
    )
    
    # 3. Merge with cover page
    merger = PdfMerger()
    merger.append("cover_template.pdf")
    for inv in invoices:
        merger.append(inv, outline_item=get_client_name(inv))
    
    # 4. Add metadata and encrypt
    merger.add_metadata({"/InvoiceCount": str(len(invoices))})
    merger.encrypt(owner_pwd="finance_team_2023")
    merger.write(f"Q3_Invoices_{datetime.now().strftime('%Y%m')}.pdf")
    
    # 5. Upload to secure storage
    upload_to_s3("secure-bucket/processed/", "Q3_Invoices.pdf")

process_monthly_invoices()

def add_to_list(item, my_list=[]):
    my_list.append(item)
    return my_list

# First call seems to work fine
print(add_to_list(1))  # Output: [1]

# Second call has unexpected behavior
print(add_to_list(2))  # Output: [1, 2] -- The list from the first call was reused!

# Third call continues the trend
print(add_to_list(3))  # Output: [1, 2, 3]

def add_to_list_safe(item, my_list=None):
    if my_list is None:
        my_list = []  # Create a new list for each call
    my_list.append(item)
    return my_list

# Each call now works independently
print(add_to_list_safe(1))  # Output: [1]
print(add_to_list_safe(2))  # Output: [2]
print(add_to_list_safe(3))  # Output: [3]