Mypy

Overview Writing code in Python feels easy until your functions start breaking in production. Brittle functions usually suffer from a lack of clear boundaries, forcing developers to guess what inputs are valid. By adopting stricter design principles—like failing fast and using explicit type hints—you can transform fragile scripts into resilient software. This guide focuses on moving away from manual type checking and toward robust error handling and clear function contracts. Prerequisites To follow this tutorial, you should understand Python basics, including defining functions, list comprehensions, and basic error handling with `try/except` blocks. Familiarity with Type Hints will help you grasp the sections on static analysis. Key Libraries & Tools * **Mypy**: A static type checker that finds bugs before you even run your code. * **Functools**: A standard library module providing tools like `single_dispatch` for function overloading. * **Lokalise**: A translation management platform used to avoid hardcoded strings in multilingual apps. * **Returns**: A library for functional programming patterns like the Maybe monad. Moving Away from Manual Type Checking Many developers litter their functions with `isinstance()` checks. This creates bloated, unreadable code. Instead of checking types at runtime, rely on type hints and static analysis tools. If you need a function to be flexible, make the type hints generic rather than writing logic that branches based on the input type. ```python from typing import Sequence, Union Avoid this: manual runtime checks def calculate_average_brittle(numbers): if not isinstance(numbers, list): raise ValueError("Expected a list") return sum(numbers) / len(numbers) Do this: Use descriptive type hints Number = Union[int, float] def calculate_average_robust(numbers: Sequence[Number]) -> float: if not numbers: raise ValueError("Cannot calculate average of an empty collection") return sum(numbers) / len(numbers) ``` Line-by-line, the robust version tells the developer exactly what to expect. It uses `Sequence` to allow lists, tuples, or sets, making the code flexible without being fragile. Enforcing Value Constraints Types only tell half the story. A function might require an integer, but specifically a *positive* one. These constraints must live inside the function. Don't assume the caller will validate data for you. Check the value immediately and raise a descriptive error if it fails the contract. ```python def initiate_client(api_key: str): if not api_key.startswith("sk-"): raise ValueError("Invalid API key format") # Proceed with client initialization ``` The Problem with Returning None Returning `None` when a search fails creates a "None-pointer" chain reaction where every subsequent function must check for `None`. This makes your code defensive and messy. Generally, you should raise a specific exception like `UserNotFoundError` if an expected object is missing. If you are filtering a list, return an empty list rather than `None`. This maintains a consistent interface for the caller. Syntax Notes & Best Practices * **Fail Fast**: Perform all checks at the very top of the function. Don't wait until halfway through a complex calculation to find out an input is invalid. * **Single Dispatch**: Use `@functools.single_dispatch` if you truly need different logic for different types, rather than long `if/elif` chains. * **Avoid Optional**: If a value isn't truly optional, don't use `Optional[T]`. Provide a sensible default value instead to keep the function body clean. Practical Examples In a real-world scenario, such as a data dashboard, using these principles ensures that a missing database record triggers a controlled error state rather than a cryptic `AttributeError: 'NoneType' object has no attribute 'name'` deep in your UI logic. Use tools like Lokalise to handle dynamic content like translations, keeping your core logic clean of hardcoded values.