Python equivalent of Typescript Omit?

by

Summary

The question revolves around finding a Python equivalent of Typescript’s Omit utility type, which creates a new type by removing certain keys from an existing type. This is crucial for type hinting and static type checking in Python, particularly with tools like mypy and pyright.

Root Cause

The root cause of this issue is the lack of a direct equivalent to Typescript’s Omit type in Python’s standard library or popular type checking tools. The main reasons include:

  • Language Design: Python’s dynamic nature and lack of explicit type definitions make it challenging to implement a direct equivalent of Omit.
  • Type Checking Tools: While mypy and pyright provide robust type checking, they do not offer a built-in Omit type.

Why This Happens in Real Systems

This issue arises in real systems when developers attempt to:

  • Migrate from Typescript: Developers familiar with Typescript’s utility types may struggle to find equivalents in Python.
  • Implement Robust Type Hinting: Python developers aiming to improve code readability and maintainability through type hinting may encounter limitations.
  • Use Static Type Checking: The absence of an Omit equivalent can hinder the effectiveness of static type checking tools.

Real-World Impact

The impact of not having a Python equivalent of Omit includes:

  • Reduced Code Readability: Without explicit type definitions, code can become less readable and more prone to errors.
  • Increased Runtime Errors: The lack of robust type hinting can lead to more runtime errors, as type-related issues are not caught during static type checking.
  • Limited Tooling Support: The absence of an Omit equivalent can limit the effectiveness of type checking tools and IDE integrations.

Example or Code

from typing import TypedDict

class Todo(TypedDict):
    title: str
    description: str
    completed: bool
    created_at: int

class TodoPreview(TypedDict):
    title: str
    completed: bool
    created_at: int

todo: TodoPreview = {
    "title": "Clean room",
    "completed": False,
    "created_at": 1615544252770,
}

How Senior Engineers Fix It

Senior engineers address this issue by:

  • Using TypedDict: As shown in the example, TypedDict can be used to create explicit type definitions for dictionaries.
  • Implementing Custom Types: Developers can create custom types using typing.Protocol or typing.NamedTuple to achieve similar results to Omit.
  • Leveraging Type Checking Tools: By utilizing mypy and pyright, developers can ensure that their type hinting is accurate and effective.

Why Juniors Miss It

Junior engineers may overlook this issue due to:

  • Lack of Familiarity: Limited experience with type hinting and static type checking tools can lead to underestimating the importance of robust type definitions.
  • Insufficient Training: Inadequate training or resources can result in junior engineers not being aware of the available alternatives to Omit in Python.
  • Focus on Runtime Behavior: Junior engineers might prioritize runtime behavior over static type checking, neglecting the benefits of explicit type definitions.

Leave a Comment