tpy-lang 0.3.0.dev0__py3-none-any.whl

tpyc/_data/lib/tpy/dataclasses.py

@@ -0,0 +1,354 @@
+# tpy: macro_module
+"""Dataclass macro for TurboPython.
+
+This module implements @dataclass as a compile-time class macro.
+It is loaded by the compiler via CPython (not compiled to C++).
+"""
+
+from tpyc.macro_api import (
+    ClassInfo, FieldInfo, TypeInfo, CallMacroContext, MacroArg, MacroError,
+    class_macro, call_macro,
+    expr_to_cpp_default, ast, types, Expr, Stmt, Function, Type,
+)
+from _macro_helpers import (
+    ORDER_DUNDERS, build_init, build_eq, build_repr, build_hash, build_order,
+)
+
+_MISSING = object()
+
+# Module-level registry: tracks which records were built by @dataclass.
+# Class macro writes here; call macros (asdict/astuple) read it.
+_dataclass_records: set[str] = set()
+
+
+class Field:
+    """Descriptor returned by field(). Inspected by @dataclass macro."""
+
+    def __init__(self, *, default=_MISSING, default_factory=_MISSING):
+        if default is not _MISSING and default_factory is not _MISSING:
+            raise TypeError("cannot specify both 'default' and 'default_factory'")
+        if default is _MISSING and default_factory is _MISSING:
+            raise TypeError("requires 'default' or 'default_factory'")
+        self.default = default
+        self.default_factory = default_factory
+
+
+def field(*, default=_MISSING, default_factory=_MISSING) -> Field:
+    """Declare field metadata in @dataclass classes."""
+    return Field(default=default, default_factory=default_factory)
+
+
+@class_macro
+def dataclass(cls: ClassInfo, *, frozen: bool = False, order: bool = False) -> None:
+    """Transform a class into a dataclass with auto-generated methods."""
+    cls.is_frozen = frozen
+
+    _process_field_defaults(cls)
+
+    # Only inherit fields from parent @dataclass records
+    parent_name = cls.parent.name if cls.parent else None
+    if parent_name and parent_name in _dataclass_records:
+        parent_fields = cls.get_parent_fields()
+        _validate_frozen_consistency(cls, frozen)
+    else:
+        parent_fields = []
+    all_fields = parent_fields + cls.fields
+    has_parent = len(parent_fields) > 0
+
+    # Synthesize __init__ (silently skipped when the user wrote one --
+    # matches CPython, which also defers to an explicit __init__).
+    if not cls.has_method("__init__"):
+        if not all_fields:
+            raise MacroError(
+                f"@dataclass class '{cls.name}' must have at least one field annotation"
+            )
+        _validate_field_order(cls, all_fields)
+        init_fn = build_init(cls, parent_fields, cls.fields)
+        cls.add_method(init_fn)
+
+    # Synthesize __eq__ (silently skipped when the user wrote one).
+    if all_fields and not cls.has_method("__eq__"):
+        eq_fn = build_eq(cls, all_fields)
+        eq_fn.hides_parent = has_parent
+        cls.add_method(eq_fn)
+
+    # Generate __repr__
+    if all_fields and not cls.has_method("__repr__"):
+        repr_fn = build_repr(cls, all_fields)
+        repr_fn.hides_parent = has_parent
+        cls.add_method(repr_fn)
+
+    # Generate __hash__ for frozen dataclasses
+    if frozen and all_fields and not cls.has_method("__hash__"):
+        hash_fn = build_hash(cls, all_fields)
+        hash_fn.hides_parent = has_parent
+        cls.add_method(hash_fn)
+
+    # Generate ordering methods
+    if order and all_fields:
+        _synthesize_order_methods(cls, all_fields, has_parent)
+
+    cls.set_match_args([f.name for f in all_fields])
+    _dataclass_records.add(cls.name)
+
+
+def _process_field_defaults(cls: ClassInfo) -> None:
+    """Unwrap Field descriptors set by field() calls."""
+    for fld in cls.fields:
+        if not isinstance(fld.default_obj, Field):
+            continue
+        spec = fld.default_obj
+        if spec.default is not _MISSING:
+            fld.set_default(spec.default, default_value=expr_to_cpp_default(spec.default))
+        elif spec.default_factory is not _MISSING:
+            factory_name = ast.get_name(spec.default_factory)
+            if factory_name is None:
+                raise MacroError(
+                    "default_factory must be a type name (e.g., list, dict, MyRecord)",
+                    loc=fld.loc,
+                )
+            factory_call = ast.call(factory_name)
+            # Preserve source location on the generated call
+            factory_call.loc = fld.loc
+            fld.set_default(factory_call, is_factory=True)
+
+
+def _validate_frozen_consistency(cls: ClassInfo, frozen: bool) -> None:
+    """Validate frozen/non-frozen consistency across inheritance."""
+    result = cls.is_parent_frozen()
+    if result is None:
+        return
+    parent_frozen, parent_name = result
+    if parent_frozen and not frozen:
+        raise MacroError(
+            f"Cannot inherit non-frozen @dataclass '{cls.name}' "
+            f"from frozen @dataclass '{parent_name}'"
+        )
+    if not parent_frozen and frozen:
+        raise MacroError(
+            f"Cannot inherit frozen @dataclass '{cls.name}' "
+            f"from non-frozen @dataclass '{parent_name}'"
+        )
+
+
+def _validate_field_order(cls: ClassInfo, all_fields: list[FieldInfo]) -> None:
+    """Validate no non-default field follows a field with default."""
+    seen_default = False
+    for fld in all_fields:
+        if fld.has_default:
+            seen_default = True
+        elif seen_default:
+            raise MacroError(
+                f"Field '{fld.name}' without default follows field with default "
+                f"in @dataclass class '{cls.name}'",
+                loc=fld.loc,
+            )
+
+
+def _synthesize_order_methods(
+    cls: ClassInfo, all_fields: list[FieldInfo], has_parent: bool,
+) -> None:
+    """Add ordering methods for @dataclass(order=True)."""
+    for dunder in ORDER_DUNDERS:
+        if cls.has_method(dunder):
+            raise MacroError(
+                f"@dataclass(order=True) cannot overwrite '{dunder}' "
+                f"defined in class '{cls.name}'"
+            )
+    for fn in build_order(cls, all_fields):
+        fn.hides_parent = has_parent
+        cls.add_method(fn)
+
+
+# ---------------------------------------------------------------------------
+# Call-site macros: asdict, astuple
+# ---------------------------------------------------------------------------
+
+@call_macro
+def asdict(ctx: CallMacroContext, obj: MacroArg) -> Expr:
+    """Convert a dataclass instance to a dict."""
+    return _build_asdict(ctx, obj.expr, obj.type)
+
+
+def _has_dc(ctx: CallMacroContext, type_info: TypeInfo) -> bool:
+    """Check if a type contains dataclass instances needing recursion."""
+    inner = type_info.unwrap_optional()
+    if inner is not None:
+        return _has_dc(ctx, inner)
+    if type_info.is_record and type_info.name in _dataclass_records:
+        return True
+    # Check dict/tuple before iterable -- iterating a dict yields keys,
+    # which would incorrectly match dict[DC_Key, V] as list[DC_Key].
+    if type_info.is_dict and len(type_info.type_args) == 2:
+        return any(_has_dc(ctx, t) for t in type_info.type_args)
+    if type_info.is_tuple and type_info.type_args:
+        return any(_has_dc(ctx, t) for t in type_info.type_args)
+    # Skip sets: the result (dict) isn't hashable, so set[DC] -> set[DC]
+    # unchanged (matches CPython). Only recurse into list-like iterables.
+    if type_info.is_set:
+        return False
+    elem = ctx.get_iterable_element_type(type_info)
+    if elem is not None and _has_dc(ctx, elem):
+        return True
+    return False
+
+
+def _value_transform(
+    ctx: CallMacroContext, access: Expr, fld_type: TypeInfo,
+    dc_fn: 'Callable',
+    value_fn: 'Callable',
+) -> Expr:
+    """Shared recursion for _asdict_value / _astuple_value.
+
+    dc_fn: called for direct dataclass fields (e.g. _build_asdict or _build_astuple)
+    value_fn: called recursively for nested elements (e.g. _asdict_value or _astuple_value)
+    """
+    # Optional[T] -> None if access is None else recurse(access, T)
+    inner = fld_type.unwrap_optional()
+    if inner is not None and _has_dc(ctx, inner):
+        # Clone to avoid sharing AST nodes between condition and body --
+        # sema sets resolved types on nodes, so reuse would cause overwrites.
+        transformed = _value_transform(ctx, ast.clone(access), inner, dc_fn, value_fn)
+        return ast.if_expr(
+            ast.binop(access, "is not", ast.none_lit()),
+            transformed,
+            ast.none_lit(),
+        )
+    if fld_type.is_record and fld_type.name in _dataclass_records:
+        return dc_fn(ctx, access, fld_type)
+    # dict/tuple before iterable (see _has_dc comment)
+    if fld_type.is_dict and len(fld_type.type_args) == 2:
+        key_type, val_type = fld_type.type_args
+        if _has_dc(ctx, key_type) or _has_dc(ctx, val_type):
+            return _build_dict_comprehension(ctx, access, key_type, val_type, value_fn)
+    if fld_type.is_tuple and fld_type.type_args:
+        if any(_has_dc(ctx, t) for t in fld_type.type_args):
+            return _build_tuple_expansion(ctx, access, fld_type.type_args, value_fn)
+    elem = ctx.get_iterable_element_type(fld_type)
+    if elem is not None and _has_dc(ctx, elem):
+        var = ast.fresh_tmp("macro")
+        return ast.list_comprehension(
+            value_fn(ctx, ast.name(var), elem),
+            ast.comprehension_generator(var, access),
+        )
+    return access
+
+
+def _build_dict_comprehension(
+    ctx: CallMacroContext, access: Expr,
+    key_type: TypeInfo, val_type: TypeInfo,
+    value_fn: 'Callable',
+) -> Expr:
+    """Expand dict field: {f(k): f(v) for k, v in field.items()}"""
+    k_var = ast.fresh_tmp("macro")
+    v_var = ast.fresh_tmp("macro")
+    items_call = ast.method_call(access, "items")
+    return ast.dict_comprehension(
+        value_fn(ctx, ast.name(k_var), key_type),
+        value_fn(ctx, ast.name(v_var), val_type),
+        ast.comprehension_generator("__comp_tup", items_call,
+                                    unpack_vars=[k_var, v_var]),
+    )
+
+
+def _build_tuple_expansion(
+    ctx: CallMacroContext, access: Expr,
+    elem_types: list[TypeInfo],
+    value_fn: 'Callable',
+) -> Expr:
+    """Expand tuple field: (f(field[0]), f(field[1]), ...)"""
+    elements = []
+    for i, elem_type in enumerate(elem_types):
+        subscript = ast.subscript(access, ast.int_lit(i))
+        elements.append(value_fn(ctx, subscript, elem_type))
+    return ast.tuple_lit(elements)
+
+
+def _asdict_value(ctx: CallMacroContext, access: Expr, fld_type: TypeInfo) -> Expr:
+    """Build the value expression for a single field in asdict expansion."""
+    return _value_transform(ctx, access, fld_type, _build_asdict, _asdict_value)
+
+
+def _build_asdict(ctx: CallMacroContext, expr: Expr, type_info: TypeInfo) -> Expr:
+    if type_info.name not in _dataclass_records:
+        raise MacroError(f"asdict() requires a @dataclass instance, got '{type_info.name}'")
+    fields = ctx.get_record_fields(type_info.name)
+    keys = []
+    values = []
+    value_tpy_types = []
+    for fld in fields:
+        keys.append(ast.str_lit(fld.name))
+        access = ast.field_access(expr, fld.name)
+        value = _asdict_value(ctx, access, fld.type)
+        values.append(value)
+        value_tpy_types.append(_asdict_result_type(ctx, fld.type))
+
+    dict_literal = ast.dict_lit(keys, values)
+
+    # For mixed-type fields, wrap in typed dict constructor: dict[str, A|B]({...})
+    unique = list(dict.fromkeys(str(t) for t in value_tpy_types))
+    if len(unique) > 1:
+        value_type = types.union(tuple(value_tpy_types))
+        return ast.call("dict", [dict_literal],
+                        call_type=types.dict(types.str, value_type))
+    return dict_literal
+
+
+def _asdict_result_type(ctx: CallMacroContext, type_info: TypeInfo) -> Type:
+    """Compute the result type for a field in asdict expansion."""
+    # Optional[T] -> Optional[result_type(T)]
+    inner = type_info.unwrap_optional()
+    if inner is not None and _has_dc(ctx, inner):
+        return types.optional(_asdict_result_type(ctx, inner))
+    # Direct dataclass
+    if type_info.is_record and type_info.name in _dataclass_records:
+        fields = ctx.get_record_fields(type_info.name)
+        if fields is None:
+            return type_info.raw_type
+        value_types = [_asdict_result_type(ctx, fld.type) for fld in fields]
+        unique = list(dict.fromkeys(str(t) for t in value_types))
+        if len(unique) > 1:
+            return types.dict(types.str, types.union(tuple(value_types)))
+        return types.dict(types.str, value_types[0])
+    # dict/tuple before iterable (same ordering as _has_dc)
+    if type_info.is_dict and len(type_info.type_args) == 2:
+        key_type, val_type = type_info.type_args
+        if _has_dc(ctx, key_type) or _has_dc(ctx, val_type):
+            return types.dict(
+                _asdict_result_type(ctx, key_type),
+                _asdict_result_type(ctx, val_type),
+            )
+    if type_info.is_tuple and type_info.type_args:
+        if any(_has_dc(ctx, t) for t in type_info.type_args):
+            return types.tuple(tuple(
+                _asdict_result_type(ctx, t) for t in type_info.type_args
+            ))
+    # list[Dataclass] -> list[dict[...]] (sets excluded by _has_dc)
+    elem = ctx.get_iterable_element_type(type_info)
+    if elem is not None and _has_dc(ctx, elem):
+        return types.list(_asdict_result_type(ctx, elem))
+    return type_info.raw_type
+
+
+@call_macro
+def astuple(ctx: CallMacroContext, obj: MacroArg) -> Expr:
+    """Convert a dataclass instance to a tuple."""
+    return _build_astuple(ctx, obj.expr, obj.type)
+
+
+def _build_astuple(ctx: CallMacroContext, expr: Expr, type_info: TypeInfo) -> Expr:
+    # Result type is inferred by sema from the element types;
+    # no explicit type annotation needed (unlike _build_asdict for mixed fields).
+    if type_info.name not in _dataclass_records:
+        raise MacroError(f"astuple() requires a @dataclass instance, got '{type_info.name}'")
+    fields = ctx.get_record_fields(type_info.name)
+    elements = []
+    for fld in fields:
+        access = ast.field_access(expr, fld.name)
+        elements.append(_astuple_value(ctx, access, fld.type))
+    return ast.tuple_lit(elements)
+
+
+def _astuple_value(ctx: CallMacroContext, access: Expr, fld_type: TypeInfo) -> Expr:
+    """Build the value expression for a single field in astuple expansion."""
+    return _value_transform(ctx, access, fld_type, _build_astuple, _astuple_value)

tpyc/_data/lib/tpy/enum.py

@@ -0,0 +1,23 @@
+# tpy: macro_module
+"""Enum module for TurboPython.
+
+Provides Enum, IntEnum base classes and auto() for member values.
+The parser resolves base class names and auto() calls to ("enum", ...)
+via normal import tracking. This module is loaded via CPython during
+compilation (not compiled to C++).
+"""
+
+
+class Enum:
+    """Base class for enumeration types."""
+    pass
+
+
+class IntEnum(Enum):
+    """Base class for integer enumeration types."""
+    pass
+
+
+def auto():
+    """Sentinel for auto-incrementing enum member values."""
+    pass

tpyc/_data/lib/tpy/functools.py

@@ -0,0 +1,33 @@
+# functools -- higher-order tools (pure TPy).
+#
+# Surface compared to CPython:
+#   - reduce(func, a, initial): 3-arg form on Iterable[T].
+#   - reduce(func, a): 2-arg form on list[T] only (random access; raises
+#     on empty). TPy lacks CPython's iter/next + StopIteration, so the
+#     2-arg form can't accept arbitrary Iterable[T].
+#   - total_ordering: re-exported from `_functools_macros` (sibling
+#     macro module).
+#
+# Gaps tracked in STDLIB_ROADMAP.md.
+# tpy: cpp_namespace("tpystd::functools")
+from typing import Iterable, overload
+from tpy import Fn, Own, copy
+from _functools_macros import total_ordering
+
+
+@overload
+def reduce[T, U](func: Fn[[U, T], U], a: Iterable[T], initial: U) -> Own[U]:
+    acc: U = copy(initial)
+    for x in a:
+        acc = func(acc, x)
+    return acc
+
+
+@overload
+def reduce[T](func: Fn[[T, T], T], a: list[T]) -> Own[T]:
+    if len(a) == 0:
+        raise ValueError("reduce() of empty list with no initial value")
+    acc: T = copy(a[0])
+    for i in range(1, len(a)):
+        acc = func(acc, a[i])
+    return acc

tpyc/_data/lib/tpy/hashlib.py

@@ -0,0 +1,206 @@
+# hashlib -- cryptographic hash algorithms.
+#
+# Only SHA-256 (FIPS 180-4) is shipped today. Pure-TPy straight-line port
+# of the reference algorithm; no SIMD, no OpenSSL binding. Correctness
+# first; an optional fast backend is a future follow-up (see
+# STDLIB_ROADMAP).
+#
+# TODO -- algorithms to add (each follows the same class + factory
+# pattern used by SHA256 below; mechanical copies differing only in
+# round function, initial state, word width, and endianness):
+#   - MD5 (RFC 1321)        -- UInt32, little-endian state, 128-bit digest
+#   - SHA-1 (FIPS 180-4)    -- UInt32, big-endian,          160-bit digest
+#   - SHA-512 (FIPS 180-4)  -- UInt64, big-endian,          512-bit digest
+#   - BLAKE2b / BLAKE2s     -- separate family, larger surface
+#   - SHA-3 / SHAKE         -- Keccak sponge, separate algorithm
+#
+# TODO -- module-level surface missing:
+#   - `hashlib.new(name, data=None)` -- factory-by-name dispatcher.
+#     Needs either a dict-of-factories or runtime type resolution.
+#   - `algorithms_available` / `algorithms_guaranteed` -- frozenset[str].
+#
+# TODO -- perf:
+#   - Bind OpenSSL / libcrypto as an optional fast backend, gated by the
+#     F8 feature-flag system (see FEATURE_ROADMAP.md). Drop-in replacement
+#     for the pure-TPy inner loop; pure-TPy stays as deps-free default.
+#
+# Language / compiler gaps hit while porting SHA-256 (see BUGS.md for
+# detail; none of them are hashlib-specific, but they shaped this file):
+#   - Default parameter value `b""` rejected as non-constant; we use
+#     `bytes | None = None` instead.
+#   - Free function with a `bytearray` param + `.append()` inside gets
+#     auto-inferred as const, producing "discards qualifiers" C++ errors.
+#     Worked around by inlining `_pack_be32` into `digest()`.
+#   - Forward-ref string annotations (`-> "SHA256"`) fail parse; class is
+#     defined before the factory to avoid them.
+#
+# Uses tpy.bits.rotr32 for rotation and UIntN.add_wrap for wrapping
+# addition (TPy's +/<< on fixed-width ints are overflow-checked; hash
+# algorithms need modular arithmetic).
+# tpy: cpp_namespace("tpystd::hashlib")
+from tpy import Int32, UInt8, UInt32, UInt64, Own
+from tpy.bits import rotr32
+
+# ---------- SHA-256 ----------
+
+_SHA256_H0: list[UInt32] = [
+    UInt32(0x6a09e667), UInt32(0xbb67ae85), UInt32(0x3c6ef372), UInt32(0xa54ff53a),
+    UInt32(0x510e527f), UInt32(0x9b05688c), UInt32(0x1f83d9ab), UInt32(0x5be0cd19),
+]
+
+_SHA256_K: list[UInt32] = [
+    UInt32(0x428a2f98), UInt32(0x71374491), UInt32(0xb5c0fbcf), UInt32(0xe9b5dba5),
+    UInt32(0x3956c25b), UInt32(0x59f111f1), UInt32(0x923f82a4), UInt32(0xab1c5ed5),
+    UInt32(0xd807aa98), UInt32(0x12835b01), UInt32(0x243185be), UInt32(0x550c7dc3),
+    UInt32(0x72be5d74), UInt32(0x80deb1fe), UInt32(0x9bdc06a7), UInt32(0xc19bf174),
+    UInt32(0xe49b69c1), UInt32(0xefbe4786), UInt32(0x0fc19dc6), UInt32(0x240ca1cc),
+    UInt32(0x2de92c6f), UInt32(0x4a7484aa), UInt32(0x5cb0a9dc), UInt32(0x76f988da),
+    UInt32(0x983e5152), UInt32(0xa831c66d), UInt32(0xb00327c8), UInt32(0xbf597fc7),
+    UInt32(0xc6e00bf3), UInt32(0xd5a79147), UInt32(0x06ca6351), UInt32(0x14292967),
+    UInt32(0x27b70a85), UInt32(0x2e1b2138), UInt32(0x4d2c6dfc), UInt32(0x53380d13),
+    UInt32(0x650a7354), UInt32(0x766a0abb), UInt32(0x81c2c92e), UInt32(0x92722c85),
+    UInt32(0xa2bfe8a1), UInt32(0xa81a664b), UInt32(0xc24b8b70), UInt32(0xc76c51a3),
+    UInt32(0xd192e819), UInt32(0xd6990624), UInt32(0xf40e3585), UInt32(0x106aa070),
+    UInt32(0x19a4c116), UInt32(0x1e376c08), UInt32(0x2748774c), UInt32(0x34b0bcb5),
+    UInt32(0x391c0cb3), UInt32(0x4ed8aa4a), UInt32(0x5b9cca4f), UInt32(0x682e6ff3),
+    UInt32(0x748f82ee), UInt32(0x78a5636f), UInt32(0x84c87814), UInt32(0x8cc70208),
+    UInt32(0x90befffa), UInt32(0xa4506ceb), UInt32(0xbef9a3f7), UInt32(0xc67178f2),
+]
+
+def _load_be32(data: bytes, off: Int32) -> UInt32:
+    return (UInt32(data[off]) << 24) | (UInt32(data[off + 1]) << 16) | (UInt32(data[off + 2]) << 8) | UInt32(data[off + 3])
+
+class SHA256:
+    h: list[UInt32]
+    buffer: bytearray
+    length: UInt64
+    digest_size: Int32
+    block_size: Int32
+    name: str
+
+    def __init__(self) -> None:
+        self.h = []
+        i: Int32 = 0
+        while i < 8:
+            self.h.append(_SHA256_H0[i])
+            i += 1
+        self.buffer = bytearray()
+        self.length = 0
+        self.digest_size = 32
+        self.block_size = 64
+        self.name = "sha256"
+
+    def update(self, data: bytes) -> None:
+        n: Int32 = Int32(len(data))
+        self.length = UInt64.add_wrap(self.length, UInt64(n))
+        k: Int32 = 0
+        while k < n:
+            self.buffer.append(data[k])
+            k += 1
+        self._drain_blocks()
+
+    def _drain_blocks(self) -> None:
+        while Int32(len(self.buffer)) >= 64:
+            self._process_block(bytes(self.buffer), 0)
+            new_buf: bytearray = bytearray()
+            j: Int32 = 64
+            total: Int32 = Int32(len(self.buffer))
+            while j < total:
+                new_buf.append(self.buffer[j])
+                j += 1
+            self.buffer = new_buf
+
+    def _process_block(self, data: bytes, off: Int32) -> None:
+        w: list[UInt32] = []
+        i: Int32 = 0
+        while i < 16:
+            w.append(_load_be32(data, off + 4 * i))
+            i += 1
+        while i < 64:
+            w15: UInt32 = w[i - 15]
+            w2: UInt32 = w[i - 2]
+            s0: UInt32 = rotr32(w15, 7) ^ rotr32(w15, 18) ^ (w15 >> 3)
+            s1: UInt32 = rotr32(w2, 17) ^ rotr32(w2, 19) ^ (w2 >> 10)
+            w.append(UInt32.add_wrap(UInt32.add_wrap(UInt32.add_wrap(w[i - 16], s0), w[i - 7]), s1))
+            i += 1
+        a: UInt32 = self.h[0]
+        b: UInt32 = self.h[1]
+        c: UInt32 = self.h[2]
+        d: UInt32 = self.h[3]
+        e: UInt32 = self.h[4]
+        f: UInt32 = self.h[5]
+        g: UInt32 = self.h[6]
+        hh: UInt32 = self.h[7]
+        t: Int32 = 0
+        while t < 64:
+            bsig1: UInt32 = rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25)
+            ch: UInt32 = (e & f) ^ ((~e) & g)
+            t1: UInt32 = UInt32.add_wrap(UInt32.add_wrap(UInt32.add_wrap(UInt32.add_wrap(hh, bsig1), ch), _SHA256_K[t]), w[t])
+            bsig0: UInt32 = rotr32(a, 2) ^ rotr32(a, 13) ^ rotr32(a, 22)
+            maj: UInt32 = (a & b) ^ (a & c) ^ (b & c)
+            t2: UInt32 = UInt32.add_wrap(bsig0, maj)
+            hh = g
+            g = f
+            f = e
+            e = UInt32.add_wrap(d, t1)
+            d = c
+            c = b
+            b = a
+            a = UInt32.add_wrap(t1, t2)
+            t += 1
+        self.h[0] = UInt32.add_wrap(self.h[0], a)
+        self.h[1] = UInt32.add_wrap(self.h[1], b)
+        self.h[2] = UInt32.add_wrap(self.h[2], c)
+        self.h[3] = UInt32.add_wrap(self.h[3], d)
+        self.h[4] = UInt32.add_wrap(self.h[4], e)
+        self.h[5] = UInt32.add_wrap(self.h[5], f)
+        self.h[6] = UInt32.add_wrap(self.h[6], g)
+        self.h[7] = UInt32.add_wrap(self.h[7], hh)
+
+    def digest(self) -> bytes:
+        clone: SHA256 = self.copy()
+        bit_len: UInt64 = UInt64.add_wrap(clone.length, clone.length)
+        bit_len = UInt64.add_wrap(bit_len, bit_len)
+        bit_len = UInt64.add_wrap(bit_len, bit_len)  # x8 for bits
+        clone.buffer.append(0x80)
+        while Int32(len(clone.buffer)) % 64 != 56:
+            clone.buffer.append(0)
+        i: Int32 = 7
+        while i >= 0:
+            shift: UInt64 = UInt64(i * 8)
+            clone.buffer.append(UInt8((bit_len >> shift) & 0xFF))
+            i -= 1
+        clone._drain_blocks()
+        out: bytearray = bytearray()
+        i = 0
+        while i < 8:
+            v: UInt32 = clone.h[i]
+            out.append(UInt8((v >> 24) & UInt32(0xFF)))
+            out.append(UInt8((v >> 16) & UInt32(0xFF)))
+            out.append(UInt8((v >> 8) & UInt32(0xFF)))
+            out.append(UInt8(v & UInt32(0xFF)))
+            i += 1
+        return bytes(out)
+
+    def hexdigest(self) -> str:
+        return self.digest().hex()
+
+    def copy(self) -> Own[SHA256]:
+        c: SHA256 = SHA256()
+        i: Int32 = 0
+        while i < 8:
+            c.h[i] = self.h[i]
+            i += 1
+        c.length = self.length
+        j: Int32 = 0
+        n: Int32 = Int32(len(self.buffer))
+        while j < n:
+            c.buffer.append(self.buffer[j])
+            j += 1
+        return c
+
+def sha256(data: bytes | None = None) -> Own[SHA256]:
+    h: SHA256 = SHA256()
+    if data is not None:
+        h.update(data)
+    return h