Enhance Your Python Coding with Typing Extensions

Typing Extensions is a Python library that serves as a powerful enhancement to the traditional typing module. By providing access to new and backported type hints that are not readily available in older Python versions, this library allows Python developers to write more readable, scalable, and reliable code with ease. In this blog post, we’ll explore dozens of APIs offered by `typing-extensions` along with practical code examples and even a small app integrating the concepts.

Why Use Typing Extensions?

With the advent of type hinting in Python, developers have been able to write type-checked and self-documenting code. However, Python’s built-in typing module takes time to include cutting-edge type-hinting features. Typing Extensions fills this gap by offering forward compatibility and experimental features. This is especially useful when working in teams or with projects requiring stable, maintainable code structure.

Key Features and APIs in Typing Extensions

TypedDict

TypedDict allows you to define dictionary-like objects with pre-defined keys and their value types:

  from typing_extensions import TypedDict

  class User(TypedDict):
      id: int
      name: str
      is_active: bool

  user: User = {"id": 1, "name": "Alice", "is_active": True}

This ensures that the dictionary adheres to the specified structure, which provides better type checking at runtime.

Literal

The Literal type allows you to specify a set of constant values for a variable or parameter:

  from typing_extensions import Literal

  def get_user_role(role: Literal["admin", "user", "guest"]) -> str:
      return f"Role is {role}"

  role = get_user_role("admin")

With Literal, you can limit the valid options available for a function or variable.

Final

The Final type marker ensures that a variable or method cannot be reassigned:

  from typing_extensions import Final

  API_KEY: Final = "12345"

  # Trying to reassign will raise a mypy error.
  # API_KEY = "67890"  # Error

Annotated

Used to attach metadata to types:

  from typing_extensions import Annotated

  UserId = Annotated[int, "A user ID"]

  def process_user_id(user_id: UserId) -> str:
      return f"Processing user ID {user_id}"

Self

The Self type is useful in methods where the return type is the same as the class:

  from typing_extensions import Self

  class FluentBuilder:
      def step_1(self) -> Self:
          print("Step 1 done")
          return self
      
      def step_2(self) -> Self:
          print("Step 2 done")
          return self

  builder = FluentBuilder().step_1().step_2()

Concatenate

Used in variadic type hints, it allows you to specify the type of arguments passed into functions dynamically. Here is one example:

  from typing_extensions import Concatenate, ParamSpec
  from typing import Callable

  P = ParamSpec("P")

  def log_args(func: Callable[Concatenate[str, P], str]) -> Callable[P, str]:
      def wrapper(*args: P.args, **kwargs: P.kwargs) -> str:
          print("Starting Function with:", args)
          return func("LOGGED", *args, **kwargs)
      return wrapper

  @log_args
  def say_hello(prefix: str, name: str) -> str:
      return f"{prefix}: Hello {name}!"
  
  print(say_hello("Alice"))

Typing Extensions in a Real World App

Let’s create a simple app that manages users using some of the above typing extensions:

  from typing_extensions import TypedDict, Final, Literal
  from typing import List

  # Defining our User schema using TypedDict
  class User(TypedDict):
      id: int
      name: str
      role: Literal["admin", "user", "guest"]

  API_VERSION: Final = "1.0"  # Final ensures this is immutable

  def filter_users(users: List[User], role: Literal["admin", "user", "guest"]) -> List[User]:
      return [user for user in users if user["role"] == role]

  # Example data
  users = [
      {"id": 1, "name": "Alice", "role": "admin"},
      {"id": 2, "name": "Bob", "role": "user"},
      {"id": 3, "name": "Carol", "role": "guest"},
  ]

  admins = filter_users(users, "admin")

  print(f"Admins found (API Version {API_VERSION}): {admins}")

In this app, we use TypedDict to define a structured dictionary for User objects, Literal to constrain input values, and Final for constants. This coding style not only ensures type safety but also improves code readability and maintainability.

Conclusion

Typing Extensions is an invaluable tool for Python developers who want the latest and greatest in type hinting without waiting for official releases in the typing module. By integrating APIs like TypedDict, Literal, and Final, your code becomes easier to maintain and debug, while also reducing runtime errors. Try out Typing Extensions today to future-proof your Python projects!