Typing Stubs for Dataclasses

Warnings

• deprecated The `types-dataclasses` PyPI package is explicitly marked as unmaintained and will not receive further updates. Stubs for `dataclasses` are now managed directly within the `typeshed` project and are typically bundled with or accessed by modern type checkers (e.g., MyPy, Pyright) automatically, making this separate package redundant.
  Fix: Remove `types-dataclasses` from your project's dependencies. Rely on your type checker's built-in `typeshed` integration for standard library stubs.
• breaking Python 3.13 introduces a breaking change in the comparison semantics for `dataclasses.dataclass` instances, specifically concerning the `__eq__` method's implementation. This change may affect code that relies on the exact comparison behavior of dataclasses, particularly when objects are identical in memory.
  Fix: Review any custom `__eq__` implementations or code that relies on specific `dataclasses` comparison behavior. Test your code with Python 3.13+ and adjust comparison logic if necessary. Refer to Python's official `dataclasses` documentation and `typeshed` for updated stub behavior.
• gotcha When using `from __future__ import annotations` (which became default in Python 3.10) with earlier Python versions (pre-3.7.6 or pre-3.8.1), inspecting type parameters of `dataclasses`' `__init__` methods could yield unexpected string representations instead of resolved types, hindering introspection-based tools.
  Fix: For older Python versions, ensure you are on a patch release that includes the fix (e.g., 3.7.6+ or 3.8.1+). For modern Python (3.10+), this is no longer an issue as deferred evaluation of annotations is the default and well-supported.
• gotcha In Python 3.9, using unparameterized generic types from the `typing` module (e.g., `List` instead of `List[str]`) within `dataclasses` could lead to runtime errors when processed by certain libraries that introspect these types. While `types-dataclasses` provides stubs, the runtime behavior can still be problematic.
  Fix: Always parameterize generic types from the `typing` module in your dataclass definitions (e.g., use `List[str]` instead of `List`). This practice is good for clarity and robustness across Python versions.

Install

• pip install types-dataclasses Install types-dataclasses (Deprecated)

Imports

• dataclass

  from dataclasses import dataclass

  The `types-dataclasses` package provides type stubs for the standard library's `dataclasses` module. User code should import directly from `dataclasses` at runtime. The stub package is consumed by type checkers for static analysis.
• field

  from dataclasses import field

  The `types-dataclasses` package provides type stubs for the standard library's `dataclasses` module. User code should import directly from `dataclasses` at runtime. The stub package is consumed by type checkers for static analysis.

Quickstart

This quickstart demonstrates the standard usage of `dataclasses` with type hints. The `types-dataclasses` package provides the necessary type definitions for static analysis tools to correctly validate such code. No direct import from `types_dataclasses` is required in user code.

from dataclasses import dataclass
from typing import List

@dataclass
class Point:
    x: int
    y: int

@dataclass
class TaggedItem:
    name: str
    tags: List[str]

def process_point(p: Point):
    print(f"Processing point: ({p.x}, {p.y})")

p = Point(10, 20)
process_point(p)

item = TaggedItem(name="Book", tags=["fiction", "novel"])
print(f"Item: {item.name}, Tags: {', '.join(item.tags)}")