Introduction to Typing Extensions in Python

Modern Python development increasingly relies on static typing to improve code clarity, maintainability, and reliability.
The typing-extensions library provides a suite of high-quality type hinting features that either supplement or
backport typing functionalities introduced in newer versions of Python. By using typing-extensions, developers
can utilize the latest type hinting features while maintaining compatibility with older Python versions.

Features of Typing Extensions with Code Snippets

1. TypedDict

TypedDict is used to define a dictionary where the keys have specific types. It is especially useful for structured data.

  from typing_extensions import TypedDict

  class Point(TypedDict):
      x: int
      y: int

  point: Point = {"x": 5, "y": 10}
  # point["x"] = "string"  # Raises a type error

2. Literal

The Literal type is used to specify that a variable or parameter can only take on a specific set of literal values.

  from typing_extensions import Literal

  def set_mode(mode: Literal["auto", "manual"]) -> None:
      print(f"Mode is set to {mode}")

  set_mode("auto")  # Valid
  # set_mode("fast")  # Raises a type error

3. Protocol

Protocols define structural subtyping or duck typing. Instead of requiring a specific class inheritance, a Protocol ensures
that a class has specific attributes/methods.

  from typing_extensions import Protocol

  class SupportsFly(Protocol):
      def fly(self) -> None:
          ...

  class Bird:
      def fly(self) -> None:
          print("Flapping wings")

  def make_fly(obj: SupportsFly) -> None:
      obj.fly()

  bird = Bird()
  make_fly(bird)  # Works since Bird implements fly()

4. Final

The Final decorator indicates that a variable, method, or class cannot be overridden or reassigned.

  from typing_extensions import Final

  MAX_USERS: Final = 100
  # MAX_USERS = 200  # Raises an error if type checker enforces Final

5. Concatenate

Concatenate is used for advanced higher-order function type signatures, manipulating argument signatures.

  from typing_extensions import Concatenate, Callable, TypeVar

  T = TypeVar("T")

  def call_with_context(func: Callable[Concatenate[str, T], None], context: str, arg: T) -> None:
      func(context, arg)

  def greet(context: str, name: str) -> None:
      print(f"{context}: Hello {name}")

  call_with_context(greet, "Greetings", "John")

6. Self

Use Self to annotate that a method returns the instance of the current class.

  from typing_extensions import Self

  class FluentBuilder:
      def set_name(self, name: str) -> Self:
          self.name = name
          return self

      def set_age(self, age: int) -> Self:
          self.age = age
          return self

7. TypeAlias

TypeAlias creates clear and reusable aliases for complex type expressions.

  from typing_extensions import TypeAlias

  Vector: TypeAlias = list[float]

  def normalize(vector: Vector) -> Vector:
      magnitude = sum(x ** 2 for x in vector) ** 0.5
      return [x / magnitude for x in vector]

  print(normalize([3.0, 4.0]))

Practical App Example Using typing-extensions

Let’s demonstrate an example application using multiple APIs from typing-extensions. The following is a simple
configuration manager for an application where we use TypedDict, Literal, and Protocol.

  from typing_extensions import Literal, Protocol, TypedDict

  class Config(TypedDict):
      app_name: str
      mode: Literal["development", "production"]
      version: str

  class Configurable(Protocol):
      def configure(self, config: Config) -> None:
          ...

  class App:
      def configure(self, config: Config) -> None:
          self.app_name = config["app_name"]
          self.mode = config["mode"]
          self.version = config["version"]
          print(f"Configured {self.app_name} in {self.mode} mode (v{self.version})")

  app = App()
  settings: Config = {"app_name": "MyApp", "mode": "production", "version": "1.0.0"}
  app.configure(settings)

This app allows us to setup configurations using strongly-typed principles provided by typing-extensions, ensuring
that our data structures and logic are robust and future-proof.

Conclusion

The typing-extensions library is indispensable for Python developers aiming for state-of-the-art type safety and
maintainability across their projects. By embracing these advanced tools, you can future-proof your Python applications and
deliver better software aligned with industry best practices.