Introduction to Typing Extensions

The Python typing-extensions library extends the capabilities of the standard typing module, providing additional tools that enable developers to specify complex type hints and bring clarity to their code. In this blog, we will explore its features with practical examples, ensuring you harness these APIs to enhance your Python applications.

Why Typing Extensions?

Typing Extensions introduces cutting-edge type hinting tools, many of which are later integrated into Python’s standard library. By using this library, you can future-proof your code, maintain compatibility with earlier Python versions, and enjoy a range of powerful type annotations.

Key APIs and Examples

1. Literal

Literal lets you constrain a value to specific literal choices, enhancing the specificity of your type hints.

  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 enables you to define type-safe dictionaries with a fixed structure and specific types.

  from typing_extensions import TypedDict

  class User(TypedDict):
      name: str
      age: int
      email: str

  user: User = {"name": "Alice", "age": 30, "email": "alice@example.com"}
  print(user["name"])  # Output: Alice

3. Final

Final prevents the reassignment of variables or overriding of methods in subclasses, ensuring immutability.

  from typing_extensions import Final

  API_URL: Final = "https://api.example.com"

  # API_URL = "https://new-api.example.com"  # Error: Cannot reassign a Final variable

4. Protocol

Protocol supports structural typing, allowing you to define interfaces based on behavior instead of inheritance.

  from typing_extensions import Protocol

  class Drivable(Protocol):
      def drive(self) -> None:
          ...

  class Car:
      def drive(self) -> None:
          print("Driving a car")

  def start_trip(vehicle: Drivable) -> None:
      vehicle.drive()

  start_trip(Car())  # Output: Driving a car

5. Annotated

Annotated attaches metadata to type hints, enhancing readability and providing contextual information.

  from typing_extensions import Annotated
  from typing import Callable

  def greet(name: Annotated[str, "Name of the person to greet"]) -> None:
      print(f"Hello, {name}!")

  greet("Alice")  # Output: Hello, Alice!

6. @override

The @override decorator ensures that a method in a subclass is overriding a base class method.

  from typing_extensions import override

  class Base:
      def greet(self) -> None:
          print("Greetings from Base")

  class Derived(Base):
      @override
      def greet(self) -> None:
          print("Greetings from Derived")

  obj = Derived()
  obj.greet()  # Output: Greetings from Derived

Building an Example Application

Let’s use Typing Extensions to create a sample application. We’ll build a REST API client with strong type hints to ensure code reliability and clarity.

  from typing_extensions import TypedDict, Final, Literal
  import requests

  class ApiResponse(TypedDict):
      status: Literal["success", "error"]
      data: dict

  API_URL: Final = "https://api.example.com"

  def fetch_data(endpoint: str) -> ApiResponse:
      response = requests.get(f"{API_URL}/{endpoint}")
      if response.status_code == 200:
          return {"status": "success", "data": response.json()}
      else:
          return {"status": "error", "data": {}}

  result = fetch_data("users")
  if result["status"] == "success":
      print("Data fetched:", result["data"])
  else:
      print("Failed to fetch data")

Conclusion

The typing-extensions library unlocks the future of Python programming by offering advanced type hinting features. By mastering its APIs like Literal, TypedDict, and Protocol, you can write more robust, type-safe, and maintainable code. Incorporate these features in your projects today and experience the difference!