2025-10-06

[MtkN1]

Today I Learned ...

[MtkN1]

Python: metaclass x dataclass_transform x dataclass implementation

import dataclasses
from typing import dataclass_transform, no_type_check


@dataclass_transform()
class ModelMeta(type):
    @no_type_check  # dynamic class creation
    def __new__(cls, name, bases, namespace, /):
        new_cls = super().__new__(cls, name, bases, namespace)
        return dataclasses.dataclass(new_cls)


class ModelBase(metaclass=ModelMeta):
    pass


class CustomerModel(ModelBase):
    id: int
    name: str


if __name__ == "__main__":
    c1 = CustomerModel(327, "John Smith")
    print(c1)

[MtkN1]

Headers dataclass

from dataclasses import dataclass, field, fields, is_dataclass
from typing import Any, dataclass_transform


# Implementations
class Header:
    def __init__(self, value: str, *values: str) -> None:
        self._values = [value, *values]

    @property
    def values(self) -> list[str]:
        return self._values


def rename_header(name: str, /) -> Any:
    return field(metadata={"header": {"rename": name}})


@dataclass_transform(field_specifiers=(rename_header,))
def headers_model[T](cls: type[T]) -> type[T]:
    return dataclass(cls)


def unstructure(instance: Any, /) -> list[tuple[str, str]]:
    if not is_dataclass(instance):
        raise TypeError("unstructure expects a dataclass instance")

    result: list[tuple[str, str]] = []

    for data_field in fields(instance):
        header_meta = data_field.metadata.get("header", {})
        rename_to = header_meta.get("rename", data_field.name)

        value = getattr(instance, data_field.name)

        if value is None:
            continue

        if isinstance(value, Header):
            for header_value in value.values:
                result.append((rename_to, header_value))
            continue

        result.append((rename_to, str(value)))

    return result


# Tests
@headers_model
class AuthHeaders:
    authorization: Header = rename_header("Authorization")


def test_unstructure() -> None:
    headers = AuthHeaders(authorization=Header("Bearer ******"))

    assert unstructure(headers) == [
        ("Authorization", "Bearer ******"),
    ]