def pretty_format()

in chz/data_model.py [0:0]

• 57 lines of code
• 24 McCabe index (conditional complexity)

def pretty_format(obj: Any, colored: bool = True) -> str:
    """Format a chz object for human readability."""
    bold = "\033[1m" if colored else ""
    blue = "\033[34m" if colored else ""
    grey = "\033[90m" if colored else ""
    reset = "\033[0m" if colored else ""
    space = " " * 4

    if isinstance(obj, (list, tuple)):
        if not obj or all(not is_chz(x) for x in obj):
            return repr(obj)

        a, b = ("[", "]") if isinstance(obj, list) else ("(", ")")
        items = [pretty_format(x, colored).replace("\n", "\n" + space) for x in obj]
        items_str = f",\n{space}".join(items)
        return f"{a}\n{space}{items_str},\n{b}"

    if isinstance(obj, dict):
        if not obj or all(not is_chz(x) for x in obj.values()):
            return repr(obj)

        items = []
        for k, v in obj.items():
            k_str = pretty_format(k, colored).replace("\n", "\n" + space)
            v_str = pretty_format(v, colored).replace("\n", "\n" + space)
            items.append(f"{k_str}: {v_str}")
        items_str = f",\n{space}".join(items)
        return f"{{\n{space}{items_str},\n}}"

    if not is_chz(obj):
        return repr(obj)

    cls_name = obj.__class__.__qualname__
    out = f"{bold}{cls_name}({reset}\n"

    def field_repr(field: Field) -> str:
        # use x_name so that repr can be copy-pasted to create the same object
        if field._repr is False:
            return "..."
        if callable(field._repr):
            r = field._repr
        else:
            assert field._repr is True
            r = lambda o: pretty_format(o, colored=colored)

        x_val = getattr(obj, field.x_name)
        val = getattr(obj, field.logical_name)
        if x_val is val:
            return r(val)
        return f"{grey}{r(x_val)}  # {reset}{r(val)}{grey} (after init){reset}"

    field_reprs: dict[bool, list[str]] = {True: [], False: []}
    for field in sorted(obj.__chz_fields__.values(), key=lambda f: f.logical_name):
        if field._default is not MISSING:
            matches_default = field._default is getattr(obj, field.x_name)
        elif field._default_factory is not MISSING:
            matches_default = field._default_factory() == getattr(obj, field.x_name)
        else:
            matches_default = False

        val_str = field_repr(field).replace("\n", "\n" + space)
        field_str = f"{space}{blue}{field.logical_name}={reset}{val_str},\n"
        field_reprs[matches_default].append(field_str)

    out += "".join(field_reprs[False])
    if field_reprs[True]:
        out += f"{space}{bold}# Fields where pre-init value matches default:{reset}\n"
        out += "".join(field_reprs[True])
    out += f"{bold}){reset}"
    return out