Typing Extensions: Enhance Your Python Type Hinting

In modern Python programming, type hints have transformed the way we write and structure code.
typing-extensions is a powerful library that provides forward compatibility for new
type hinting features before they are officially included in the Python standard library. This allows
developers to leverage cutting-edge type hinting in their projects.

Core Features of Typing Extensions

The library offers a range of utilities to extend Python’s type hint capabilities.

1. TypedDict

The TypedDict class enables typed dictionaries, where you can define the types of keys and values ahead of time.

      from typing_extensions import TypedDict

      class Movie(TypedDict):
          title: str
          year: int
          rating: float

      movie: Movie = {
          "title": "Inception",
          "year": 2010,
          "rating": 8.8
      }
    

2. Protocol

Use Protocol to define structural subtyping. This allows you to specify what methods or attributes a class should have,
without needing inheritance.

      from typing_extensions import Protocol

      class Drawable(Protocol):
          def draw(self) -> None:
              ...

      class Circle:
          def draw(self) -> None:
              print("Drawing a circle!")

      def render(obj: Drawable) -> None:
          obj.draw()

      circle = Circle()
      render(circle)  # Outputs: Drawing a circle!
    

3. Literal

The Literal allows restricting a variable to a set of fixed values, enabling more precise type-checking.

      from typing_extensions import Literal

      def get_status(code: Literal["success", "error", "pending"]) -> str:
          return f"Status is {code}"

      print(get_status("success"))  # Valid
      # print(get_status("invalid"))  # Error: Argument is not a valid Literal
    

4. Final

Final can be used to flag variables or methods that should not be reassigned or overridden.

      from typing_extensions import Final

      MAX_USERS: Final[int] = 100

      class Config:
          @Final
          def get_config(self) -> None:
              pass
    

5. Self

Self provides a more precise way to annotate instance methods returning the current class type.

      from typing_extensions import Self

      class MyClass:
          def add_value(self, value: int) -> Self:
              self.value = value
              return self
    

6. Annotated

Use Annotated for attaching metadata to types.

      from typing import Annotated
      from typing_extensions import Annotated

      def process(value: Annotated[int, "Metadata for documentation"]) -> None:
          pass
    

7. Overload

Define multiple function signatures with Overload for better type resolution.

      from typing_extensions import overload

      @overload
      def greet(name: str) -> str: ...

      @overload
      def greet(age: int) -> str: ...

      def greet(data) -> str:
          if isinstance(data, str):
              return f"Hello {data}!"
          elif isinstance(data, int):
              return f"Wow, you're {data} years old!"

      print(greet("Alex"))  # Outputs: Hello Alex!
      print(greet(25))  # Outputs: Wow, you're 25 years old!
    

Real-world Application Example

Let’s develop a small Python application using the APIs introduced above. We’ll create a library management system that utilizes advanced type hinting.

      from typing_extensions import TypedDict, Literal, Protocol, Final

      class Book(TypedDict):
          title: str
          author: str
          year: int

      MAX_BOOKS: Final[int] = 1000

      class Action(Protocol):
          def perform(self, book: Book) -> None:
              ...

      class AddBook:
          def __init__(self, library: list[Book]):
              self.library = library

          def perform(self, book: Book) -> None:
              if len(self.library) < MAX_BOOKS:
                  self.library.append(book)
                  print(f"Added: {book['title']}")

      class RemoveBook:
          def __init__(self, library: list[Book]):
              self.library = library

          def perform(self, book: Book) -> None:
              if book in self.library:
                  self.library.remove(book)
                  print(f"Removed: {book['title']}")

      library: list[Book] = []

      add_action = AddBook(library)
      remove_action = RemoveBook(library)

      book_1: Book = {"title": "1984", "author": "George Orwell", "year": 1949}
      book_2: Book = {"title": "Dune", "author": "Frank Herbert", "year": 1965}

      add_action.perform(book_1)  # Adds '1984' to the library
      add_action.perform(book_2)  # Adds 'Dune' to the library
      remove_action.perform(book_1)  # Removes '1984' from the library
    

The above application is an elegant demonstration of how typing-extensions APIs can structure robust, type-safe Python code.

Conclusion

The typing-extensions library empowers Python developers to write more maintainable and scalable code by providing
access to advanced type hinting features. Whether you’re building a small script or a large-scale application, incorporating
these extensions enhances code clarity and promotes strong typing.