	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Modern Python > Type Hints and Dataclasses > Python Type Hints and Dataclasses

Python Type Hints and Dataclasses

Author: Venkata Sudhakar

Python type hints, introduced in Python 3.5 via PEP 484, allow you to annotate variable types, function parameters, and return values with their expected types. Python does not enforce these at runtime by default - they are hints for static analysis tools like mypy and pyright, and for IDEs that use them to provide better autocompletion, error detection, and refactoring support. In modern Python development, especially for applications involving data migration pipelines, AI systems, and APIs, type hints are considered essential for maintainable, production-quality code.

The dataclass decorator (Python 3.7+) automatically generates __init__, __repr__, __eq__, and other dunder methods for classes that are primarily used to store data. This eliminates the boilerplate of writing these methods manually while preserving full type hint support. Combined with frozen=True, slots=True, and field() for defaults, dataclasses are the preferred way to define data structures in modern Python - often replacing NamedTuples and plain dicts for structured data.

The below example shows comprehensive type hint syntax and practical dataclass usage for a data migration domain model.

from __future__ import annotations
from typing import Optional, Union, List, Dict, Tuple, Any, Callable
from collections.abc import Sequence, Iterator

# Basic type hints
def greet(name: str) -> str:
    return f"Hello, {name}"

# Optional: the value can be the type or None
def find_user(user_id: int) -> Optional[str]:
    users = {1: "Alice", 2: "Bob"}
    return users.get(user_id)  # Returns str or None

# Union: multiple possible types (Python 3.10+ can use X | Y syntax)
def process_id(record_id: Union[int, str]) -> str:
    return str(record_id)

# Generic collections with type parameters
def get_table_names(schema: Dict[str, List[str]]) -> List[str]:
    return list(schema.keys())

# Callable type hints for function arguments
def run_with_retry(fn: Callable[[str], bool], arg: str, retries: int = 3) -> bool:
    for attempt in range(retries):
        if fn(arg):
            return True
    return False

# Python 3.10+ union syntax
def parse_value(value: int | str | None) -> str:
    if value is None:
        return "null"
    return str(value)

print(greet("Venkata"))
print(find_user(1))
print(find_user(99))
print(parse_value(None))
print(parse_value(42))

It gives the following output,

Hello, Venkata
Alice
None
null
42

from dataclasses import dataclass, field
from typing import Optional, List
from datetime import datetime
from enum import Enum

class MigrationStatus(Enum):
    PENDING = "PENDING"
    IN_PROGRESS = "IN_PROGRESS"
    COMPLETED = "COMPLETED"
    FAILED = "FAILED"

@dataclass
class TableMigrationSpec:
    table_name: str
    source_schema: str
    target_schema: str
    estimated_rows: int
    # Fields with defaults must come after fields without defaults
    priority: int = 1
    include_indexes: bool = True
    exclude_columns: List[str] = field(default_factory=list)
    notes: Optional[str] = None

@dataclass
class MigrationJob:
    job_id: str
    source_db: str
    target_db: str
    tables: List[TableMigrationSpec] = field(default_factory=list)
    status: MigrationStatus = MigrationStatus.PENDING
    created_at: datetime = field(default_factory=datetime.utcnow)
    completed_at: Optional[datetime] = None

def total_rows(self) -> int:
        return sum(t.estimated_rows for t in self.tables)

def is_complete(self) -> bool:
        return self.status == MigrationStatus.COMPLETED

# Create instances - __init__ is auto-generated by @dataclass
spec1 = TableMigrationSpec(
    table_name="customers",
    source_schema="mysql_prod",
    target_schema="pg_prod",
    estimated_rows=125000,
    exclude_columns=["ssn", "credit_card_hash"]
)
spec2 = TableMigrationSpec(
    table_name="orders",
    source_schema="mysql_prod",
    target_schema="pg_prod",
    estimated_rows=892000,
    priority=2
)
job = MigrationJob(
    job_id="MIG-1042",
    source_db="mysql://prod:3306/appdb",
    target_db="postgresql://pg-host:5432/appdb",
    tables=[spec1, spec2]
)
print(job)
print(f"Total rows: {job.total_rows():,}")
print(f"Status: {job.status.value}")
print(f"Complete: {job.is_complete()}")

It gives the following output,

MigrationJob(
  job_id="MIG-1042",
  source_db="mysql://prod:3306/appdb",
  target_db="postgresql://pg-host:5432/appdb",
  tables=[
    TableMigrationSpec(table_name="customers", estimated_rows=125000,
      exclude_columns=["ssn", "credit_card_hash"]),
    TableMigrationSpec(table_name="orders", estimated_rows=892000, priority=2)
  ],
  status=
)
Total rows: 1,017,000
Status: PENDING
Complete: False

Key type hint features to know:

TypedDict - Annotate dictionary shapes with specific key types: from typing import TypedDict. Used extensively in LangGraph state definitions. Protocol - Define structural interfaces (duck typing): a class "implements" a Protocol if it has the required methods, without explicit inheritance. Generic - Write type-safe generic classes and functions: class Stack(Generic[T]): ... Final - Mark constants that should never be reassigned: MAX_RETRIES: Final = 3. Static analysis tools like mypy catch violations at build time, before they reach production.

Send your comments, suggestions or queries regarding this site to [email protected].