Introduction to Python Typing-Extensions

The typing-extensions module is a valuable library in Python that provides backported and experimental type hints for earlier Python versions. It allows you to use the latest typing features introduced in standard Python, even if your Python version isn’t the latest one. This library ensures type consistency, fosters code readability, and aids in writing robust applications. In this blog, we’ll explore key APIs in typing-extensions and illustrate use cases via examples and a sample application.

Why Use Typing-Extensions?

Python is evolving, and its type hinting capabilities are improving with each version. However, developers using older Python versions sometimes cannot access the latest type features. This is where typing-extensions shines. It makes possible:

• Backward compatibility for new type hints.
• Access to experimental or future type annotations.
• Writing better-typed Python programs.

Key APIs in Typing-Extensions with Examples

1. Literal

The Literal type restricts a variable to a specific set of values.

  from typing_extensions import Literal

  def get_status_code(status: Literal['success', 'error']) -> int:
      if status == 'success':
          return 200
      elif status == 'error':
          return 500

  print(get_status_code('success'))  # Output: 200

2. TypedDict

TypedDict represents a dictionary with a specific structure.

  from typing_extensions import TypedDict

  class User(TypedDict):
      name: str
      age: int
      active: bool

  user_data: User = {'name': 'Alice', 'age': 30, 'active': True}
  print(user_data['name'])  # Output: Alice

3. Final

The Final annotates fields or variables that cannot be reassigned.

  from typing_extensions import Final

  MAX_USERS: Final = 100

  def add_users(count: int):
      global MAX_USERS
      # Uncommenting the next line will throw an error
      # MAX_USERS = count
      print(f"Users can be up to: {MAX_USERS}")

4. Annotated

The Annotated API lets you attach metadata to types.

  from typing_extensions import Annotated

  def process_data(data: Annotated[int, "Must be non-negative"]) -> int:
      assert data >= 0, "Data must be non-negative"
      return data * 2

  print(process_data(42))  # Output: 84

5. Self

The Self type allows methods to return the same type as the class they belong to.

  from typing_extensions import Self

  class FluentBuilder:
      def __init__(self):
          self.data = []

      def add(self, value) -> Self:
          self.data.append(value)
          return self

  builder = FluentBuilder()
  builder.add(10).add(20)
  print(builder.data)  # Output: [10, 20]

Practical App Using Typing-Extensions

Let’s create a small application that models a type-safe inventory system using the TypedDict and Literal APIs.

  from typing_extensions import TypedDict, Literal

  # Type definitions
  class Product(TypedDict):
      id: int
      name: str
      category: Literal['Electronics', 'Apparel', 'Food']
      price: float

  inventory: list[Product] = []

  def add_product(product: Product) -> None:
      inventory.append(product)

  def list_inventory() -> list[Product]:
      return inventory

  def find_product_by_category(category: Literal['Electronics', 'Apparel', 'Food']) -> list[Product]:
      return [prod for prod in inventory if prod['category'] == category]

  # Example usage
  add_product({'id': 1, 'name': 'Laptop', 'category': 'Electronics', 'price': 1099.99})
  add_product({'id': 2, 'name': 'T-Shirt', 'category': 'Apparel', 'price': 19.99})
  print(list_inventory())
  print(find_product_by_category('Electronics'))

Conclusion

The typing-extensions module bridges the gap between older Python versions and newer typing capabilities. By using its features, you can write cleaner and safer code while ensuring future compatibility. Whether you’re enforcing strict type restrictions with Literal or defining structured dictionaries with TypedDict, this library has you covered. Bookmark this page and experiment with these type hints to enhance your Python coding journey!