Python Anti Patterns

1---2name: python-anti-patterns3description: Use this skill when reviewing Python code for common anti-patterns to avoid. Use as a checklist when reviewing code, before finalizing implementations, or when debugging issues that might stem from known bad practices.4---5 6# Python Anti-Patterns Checklist7 8A reference checklist of common mistakes and anti-patterns in Python code. Review this before finalizing implementations to catch issues early.9 10## When to Use This Skill11 12- Reviewing code before merge13- Debugging mysterious issues14- Teaching or learning Python best practices15- Establishing team coding standards16- Refactoring legacy code17 18**Note:** This skill focuses on what to avoid. For guidance on positive patterns and architecture, see the `python-design-patterns` skill.19 20## Infrastructure Anti-Patterns21 22### Scattered Timeout/Retry Logic23 24```python25# BAD: Timeout logic duplicated everywhere26def fetch_user(user_id):27    try:28        return requests.get(url, timeout=30)29    except Timeout:30        logger.warning("Timeout fetching user")31        return None32 33def fetch_orders(user_id):34    try:35        return requests.get(url, timeout=30)36    except Timeout:37        logger.warning("Timeout fetching orders")38        return None39```40 41**Fix:** Centralize in decorators or client wrappers.42 43```python44# GOOD: Centralized retry logic45@retry(stop=stop_after_attempt(3), wait=wait_exponential())46def http_get(url: str) -> Response:47    return requests.get(url, timeout=30)48```49 50### Double Retry51 52```python53# BAD: Retrying at multiple layers54@retry(max_attempts=3)  # Application retry55def call_service():56    return client.request()  # Client also has retry configured!57```58 59**Fix:** Retry at one layer only. Know your infrastructure's retry behavior.60 61### Hard-Coded Configuration62 63```python64# BAD: Secrets and config in code65DB_HOST = "prod-db.example.com"66API_KEY = "sk-12345"67 68def connect():69    return psycopg.connect(f"host={DB_HOST}...")70```71 72**Fix:** Use environment variables with typed settings.73 74```python75# GOOD76from pydantic_settings import BaseSettings77 78class Settings(BaseSettings):79    db_host: str = Field(alias="DB_HOST")80    api_key: str = Field(alias="API_KEY")81 82settings = Settings()83```84 85## Architecture Anti-Patterns86 87### Exposed Internal Types88 89```python90# BAD: Leaking ORM model to API91@app.get("/users/{id}")92def get_user(id: str) -> UserModel:  # SQLAlchemy model93    return db.query(UserModel).get(id)94```95 96**Fix:** Use DTOs/response models.97 98```python99# GOOD100@app.get("/users/{id}")101def get_user(id: str) -> UserResponse:102    user = db.query(UserModel).get(id)103    return UserResponse.from_orm(user)104```105 106### Mixed I/O and Business Logic107 108```python109# BAD: SQL embedded in business logic110def calculate_discount(user_id: str) -> float:111    user = db.query("SELECT * FROM users WHERE id = ?", user_id)112    orders = db.query("SELECT * FROM orders WHERE user_id = ?", user_id)113    # Business logic mixed with data access114    if len(orders) > 10:115        return 0.15116    return 0.0117```118 119**Fix:** Repository pattern. Keep business logic pure.120 121```python122# GOOD123def calculate_discount(user: User, orders: list[Order]) -> float:124    # Pure business logic, easily testable125    if len(orders) > 10:126        return 0.15127    return 0.0128```129 130## Error Handling Anti-Patterns131 132### Bare Exception Handling133 134```python135# BAD: Swallowing all exceptions136try:137    process()138except Exception:139    pass  # Silent failure - bugs hidden forever140```141 142**Fix:** Catch specific exceptions. Log or handle appropriately.143 144```python145# GOOD146try:147    process()148except ConnectionError as e:149    logger.warning("Connection failed, will retry", error=str(e))150    raise151except ValueError as e:152    logger.error("Invalid input", error=str(e))153    raise BadRequestError(str(e))154```155 156### Ignored Partial Failures157 158```python159# BAD: Stops on first error160def process_batch(items):161    results = []162    for item in items:163        result = process(item)  # Raises on error - batch aborted164        results.append(result)165    return results166```167 168**Fix:** Capture both successes and failures.169 170```python171# GOOD172def process_batch(items) -> BatchResult:173    succeeded = {}174    failed = {}175    for idx, item in enumerate(items):176        try:177            succeeded[idx] = process(item)178        except Exception as e:179            failed[idx] = e180    return BatchResult(succeeded, failed)181```182 183### Missing Input Validation184 185```python186# BAD: No validation187def create_user(data: dict):188    return User(**data)  # Crashes deep in code on bad input189```190 191**Fix:** Validate early at API boundaries.192 193```python194# GOOD195def create_user(data: dict) -> User:196    validated = CreateUserInput.model_validate(data)197    return User.from_input(validated)198```199 200## Resource Anti-Patterns201 202### Unclosed Resources203 204```python205# BAD: File never closed206def read_file(path):207    f = open(path)208    return f.read()  # What if this raises?209```210 211**Fix:** Use context managers.212 213```python214# GOOD215def read_file(path):216    with open(path) as f:217        return f.read()218```219 220### Blocking in Async221 222```python223# BAD: Blocks the entire event loop224async def fetch_data():225    time.sleep(1)  # Blocks everything!226    response = requests.get(url)  # Also blocks!227```228 229**Fix:** Use async-native libraries.230 231```python232# GOOD233async def fetch_data():234    await asyncio.sleep(1)235    async with httpx.AsyncClient() as client:236        response = await client.get(url)237```238 239## Type Safety Anti-Patterns240 241### Missing Type Hints242 243```python244# BAD: No types245def process(data):246    return data["value"] * 2247```248 249**Fix:** Annotate all public functions.250 251```python252# GOOD253def process(data: dict[str, int]) -> int:254    return data["value"] * 2255```256 257### Untyped Collections258 259```python260# BAD: Generic list without type parameter261def get_users() -> list:262    ...263```264 265**Fix:** Use type parameters.266 267```python268# GOOD269def get_users() -> list[User]:270    ...271```272 273## Testing Anti-Patterns274 275### Only Testing Happy Paths276 277```python278# BAD: Only tests success case279def test_create_user():280    user = service.create_user(valid_data)281    assert user.id is not None282```283 284**Fix:** Test error conditions and edge cases.285 286```python287# GOOD288def test_create_user_success():289    user = service.create_user(valid_data)290    assert user.id is not None291 292def test_create_user_invalid_email():293    with pytest.raises(ValueError, match="Invalid email"):294        service.create_user(invalid_email_data)295 296def test_create_user_duplicate_email():297    service.create_user(valid_data)298    with pytest.raises(ConflictError):299        service.create_user(valid_data)300```301 302### Over-Mocking303 304```python305# BAD: Mocking everything306def test_user_service():307    mock_repo = Mock()308    mock_cache = Mock()309    mock_logger = Mock()310    mock_metrics = Mock()311    # Test doesn't verify real behavior312```313 314**Fix:** Use integration tests for critical paths. Mock only external services.315 316## Quick Review Checklist317 318Before finalizing code, verify:319 320- [ ] No scattered timeout/retry logic (centralized)321- [ ] No double retry (app + infrastructure)322- [ ] No hard-coded configuration or secrets323- [ ] No exposed internal types (ORM models, protobufs)324- [ ] No mixed I/O and business logic325- [ ] No bare `except Exception: pass`326- [ ] No ignored partial failures in batches327- [ ] No missing input validation328- [ ] No unclosed resources (using context managers)329- [ ] No blocking calls in async code330- [ ] All public functions have type hints331- [ ] Collections have type parameters332- [ ] Error paths are tested333- [ ] Edge cases are covered334 335## Common Fixes Summary336 337| Anti-Pattern | Fix |338|-------------|-----|339| Scattered retry logic | Centralized decorators |340| Hard-coded config | Environment variables + pydantic-settings |341| Exposed ORM models | DTO/response schemas |342| Mixed I/O + logic | Repository pattern |343| Bare except | Catch specific exceptions |344| Batch stops on error | Return BatchResult with successes/failures |345| No validation | Validate at boundaries with Pydantic |346| Unclosed resources | Context managers |347| Blocking in async | Async-native libraries |348| Missing types | Type annotations on all public APIs |349| Only happy path tests | Test errors and edge cases |