Enhance Your Python Projects with Typing-Extensions

The typing-extensions library is a powerful tool that extends the functionality of Python’s native typing module. It provides new type hints and utilities that are introduced in newer versions of Python, while also maintaining compatibility with older versions. This makes it invaluable for developers looking to use advanced typing features without sacrificing backward compatibility.

In this blog post, we’ll explore the most useful APIs introduced by typing-extensions, complete with code snippets to demonstrate how they can supercharge your projects. Let’s dive in!

1. Annotated

The Annotated type allows you to associate metadata with types. This can be useful for tools like linters or runtime frameworks.

  from typing_extensions import Annotated

  # Add metadata to a type
  Age = Annotated[int, "must be a non-negative integer"]

  def process_age(age: Age):
      print(f"Processing age: {age}")

  process_age(25)

2. Literal

Literal helps you restrict a value to a specific set of possibilities.

  from typing_extensions import Literal

  # Define restricted string values
  Animal = Literal["cat", "dog", "bird"]

  def make_sound(animal: Animal):
      if animal == "cat":
          return "Meow"
      elif animal == "dog":
          return "Woof"
      else:
          return "Chirp"

  print(make_sound("cat"))

3. TypedDict

TypedDict lets you create dictionary-like structures with specific keys and value types.

  from typing_extensions import TypedDict

  # Define a TypedDict for a movie
  class Movie(TypedDict):
      title: str
      year: int
      genre: str

  def show_movie_info(movie: Movie):
      print(f"Title: {movie['title']} ({movie['year']}), Genre: {movie['genre']}")

  movie = {"title": "Inception", "year": 2010, "genre": "Sci-Fi"}
  show_movie_info(movie)

4. Final

Use Final to indicate that a variable or attribute cannot be reassigned.

  from typing_extensions import Final

  MAX_CONNECTIONS: Final = 10
  # MAX_CONNECTIONS = 20  # This would raise a typing error in tools like mypy

5. @runtime_checkable with Protocol

@runtime_checkable combined with Protocol is used for structural subtyping, even during runtime.

  from typing_extensions import Protocol, runtime_checkable

  @runtime_checkable
  class Greeter(Protocol):
      def greet(self) -> str:
          ...

  class Person:
      def greet(self) -> str:
          return "Hello!"

  assert isinstance(Person(), Greeter)

6. Never

Never is used to indicate functions that never return (e.g., they always raise exceptions or run forever).

  from typing_extensions import Never

  def raise_error() -> Never:
      raise RuntimeError("This function never returns")

  try:
      raise_error()
  except RuntimeError:
      print("Caught an error!")

7. Self

The Self type hint is useful for specifying methods that return an instance of their class.

  from typing_extensions import Self

  class MyClass:
      def chain(self) -> Self:
          print("Chaining...")
          return self

  obj = MyClass()
  obj.chain().chain()

8. Demonstration App

Let’s build a simple app that combines these features. We’ll create a task organizer app using TypedDict, Literal, and more.

  from typing_extensions import TypedDict, Literal, Annotated

  class Task(TypedDict):
      title: str
      priority: Literal["High", "Medium", "Low"]
      completed: bool

  def create_task(title: str, priority: Literal["High", "Medium", "Low"]) -> Task:
      return {"title": title, "priority": priority, "completed": False}

  def complete_task(task: Task):
      task["completed"] = True

  # Example usage
  task1 = create_task("Write blog post", "High")
  task2 = create_task("Read book", "Medium")

  complete_task(task1)

  print(task1)
  print(task2)

Conclusion

The typing-extensions library empowers developers with advanced typing capabilities that make Python code more robust, maintainable, and expressive. By leveraging features like Annotated, Literal, and TypedDict, you can take your projects to the next level. Try incorporating these features into your next Python application to experience the benefits yourself!