freedos-micro-python 0.1.0__py3-none-any.whl

freedos_micro_python/__init__.py

@@ -0,0 +1,8 @@
+"""freedos_micro_python - MicroPython port for FreeDOS / i386 via uc386."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("freedos_micro_python")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"

freedos_micro_python/cli.py

@@ -0,0 +1,106 @@
+"""freedos-micropython CLI: builds the FreeDOS MicroPython binary.
+
+Subcommands:
+    fetch    Run scripts/fetch.sh to clone upstream MicroPython.
+    build    Run scripts/build.sh (per-TU triage build, generates qstrdefs).
+    port     Run scripts/build_port.sh (multi-TU build → micropython.bin).
+
+Each subcommand is a thin wrapper around the bundled shell script. The
+wrapper:
+
+  1. Locates uc386's lib/ via the installed package and exports
+     UC386_LIB_INCLUDE so the scripts don't have to compute it.
+  2. Picks a working directory: uses --workdir if given, else cwd.
+  3. Execs the script with stdin/stdout/stderr passed through.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+from importlib.resources import files
+from pathlib import Path
+
+
+def _uc386_lib_include() -> Path:
+    import uc386
+    return Path(uc386.__file__).resolve().parent / "lib" / "include"
+
+
+def _scripts_dir() -> Path:
+    return Path(str(files("freedos_micro_python") / "scripts"))
+
+
+def _port_dir() -> Path:
+    return Path(str(files("freedos_micro_python") / "port"))
+
+
+def _ensure_port_symlink(workdir: Path) -> None:
+    """The shipped scripts reference port files as `uc386-dos/foo.c`.
+    Make sure `workdir/uc386-dos` points at the bundled port dir so
+    those references resolve regardless of where the user is running
+    from."""
+    link = workdir / "uc386-dos"
+    target = _port_dir()
+    if link.is_symlink():
+        if link.resolve() == target.resolve():
+            return
+        link.unlink()
+    elif link.exists():
+        # Real directory at uc386-dos/ — leave it alone, user knows
+        # what they're doing.
+        return
+    link.symlink_to(target)
+
+
+def _run_script(name: str, workdir: Path, extra_args: list[str]) -> int:
+    script = _scripts_dir() / name
+    if not script.exists():
+        print(f"freedos-micropython: bundled script not found: {script}",
+              file=sys.stderr)
+        return 1
+    env = os.environ.copy()
+    env["UC386_LIB_INCLUDE"] = str(_uc386_lib_include())
+    env["FREEDOS_MP_PORT_DIR"] = str(_port_dir())
+    env["FREEDOS_MP_SCRIPTS_DIR"] = str(_scripts_dir())
+    workdir.mkdir(parents=True, exist_ok=True)
+    _ensure_port_symlink(workdir)
+    return subprocess.run(
+        [str(script), *extra_args],
+        cwd=workdir, env=env,
+    ).returncode
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="freedos-micropython",
+        description=(
+            "Build the FreeDOS / i386 MicroPython port end-to-end "
+            "through the uc386 C23 compiler. Produces a flat .bin "
+            "runnable under uc386.dos_emu (or a PMODE/W .exe via "
+            "uc386's exe.py harness)."
+        ),
+    )
+    ap.add_argument(
+        "--workdir", type=Path, default=Path.cwd(),
+        help="Directory the build runs in (upstream/ and build/ "
+             "land here). Default: current dir.",
+    )
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("fetch", help="Clone upstream micropython into ./upstream")
+    sub.add_parser("build", help="Per-TU triage build (generates qstrdefs)")
+    sub.add_parser("port",  help="Multi-TU build → build/micropython.bin")
+
+    ns, extra = ap.parse_known_args(argv)
+    script_map = {
+        "fetch": "fetch.sh",
+        "build": "build.sh",
+        "port":  "build_port.sh",
+    }
+    return _run_script(script_map[ns.cmd], ns.workdir, extra)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

freedos_micro_python/gen_qstrdefs.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+"""Reverse-mangle MP_QSTR_<sanitized> macro names back to the
+original qstr source string.
+
+Upstream's `tools/makeqstrdata.py:qstr_escape` walks each qstr and
+replaces every non-`[A-Za-z0-9]` byte with `_<name>_`, where
+`<name>` comes from `codepoint2name` (HTML entity names + a small
+custom map) or `0x%02x` for the rest. Our triage build greps for
+`MP_QSTR_<sanitized>` references in the source; the *macro* name
+is what's been sanitized — the original qstr string for `\\n` is
+1 byte, but it appears in source as `MP_QSTR__0x0a_` (5-byte
+sanitized form). If we emit the sanitized form as the qstr's
+4th-field string, `qstr_find_strn("\\n", 1)` misses, AND output
+qstrs (e.g. `print()`'s trailing newline) render as the literal
+text `_0x0a_` instead of a newline.
+
+This script reads MP_QSTR_<x> tokens on stdin (one per line, may
+contain dups), reverses the escape, and emits one
+`QDEF1(macro, 0, len, "<orig>")` line per UNIQUE token sorted by
+the **original string** (ASCII byte order). Sort key matters:
+qstr_find_strn does `strncmp(probe_str, pool->qstrs[mid], n)` —
+the comparison key at runtime is the un-escaped string, so the
+pool's `is_sorted=true` invariant requires that order. Sorting
+by macro name happens to coincide for pure-identifier qstrs
+(`print`, `__name__`) but breaks for escaped ones
+(`MP_QSTR__0x0a_` lex-orders near `_`, while its actual string
+`\\n` = 0x0A would sort before space).
+"""
+from __future__ import annotations
+
+import sys
+
+# Pull codepoint2name from upstream verbatim — same source of truth
+# as makeqstrdata.qstr_escape so the inverse is exact. Caller is
+# expected to set sys.path so `upstream.py.makeqstrdata` resolves.
+sys.path.insert(0, "upstream/py")
+from makeqstrdata import codepoint2name  # type: ignore[import-not-found]
+
+# Inverse map: HTML entity name -> single-character byte string.
+# Two filters:
+#   1. Codepoint must be < 256 — qstrs are byte sequences, so
+#      escapes for high-codepoint Unicode chars never appear in real
+#      source. Without this, `_omega_` etc. would false-match.
+#   2. The decoded char must NOT itself be an identifier char
+#      (`[A-Za-z0-9_]`). Upstream's `qstr_escape` only produces
+#      `_<name>_` wrappers for NON-identifier chars (the regex
+#      `RE_NO_ESCAPE = r"[A-Za-z0-9_]"` passes identifier chars
+#      through unchanged). So `_<name>_` in a macro tail can only
+#      have come from escaping a punctuation/whitespace byte —
+#      never from an alphanumeric escape. This filter eliminates
+#      false matches like `__not__` (a real Python dunder, not an
+#      escape of `¬` U+00AC) and `__and__` (likewise, not `∧`).
+_IDENT_CHARS = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_")
+# Restrict to ASCII printable punctuation (32–126, excluding the
+# identifier subset). Control chars (`\n`, `\t`, …) and high-byte
+# chars (¬ U+00AC, ∧ U+2227, Α U+0391, …) are handled either via
+# the `0x%02x` literal path or are simply unreachable in real qstr
+# source — `__not__` is a real Python dunder, not an escape for `¬`.
+name2char = {
+    name: chr(cp)
+    for cp, name in codepoint2name.items()
+    if 32 <= cp <= 126 and chr(cp) not in _IDENT_CHARS
+}
+
+
+def unescape(macro_tail: str) -> str:
+    """Reverse qstr_escape on the part after `MP_QSTR_`.
+
+    Walks left-to-right. Plain `[A-Za-z0-9]` runs pass through.
+    A `_<name>_` group decodes to a single byte: `name` is either
+    an HTML entity name (`lt`, `gt`, `space`, `hyphen`, ...) or a
+    `0x%02x` literal. The leading `_` and trailing `_` framing the
+    name come from `qstr_escape`'s `"_" + name + "_"` template.
+
+    Edge case: an underscore that's part of the *original* string
+    (e.g. `__name__`) ALSO gets sanitized — but to itself, since
+    `_` is in `RE_NO_ESCAPE` upstream:
+
+        RE_NO_ESCAPE = re.compile(r"[A-Za-z0-9_]")
+
+    So plain `_` runs through verbatim. The only `_<name>_` groups
+    that exist are the genuine escape sequences. Disambiguating
+    works because every escape `name` is at minimum 2 chars
+    (`lt`, `gt`, `0x..`) — a lone `_` is never a wrapper.
+    """
+    out: list[str] = []
+    i = 0
+    n = len(macro_tail)
+    while i < n:
+        c = macro_tail[i]
+        if c != "_":
+            out.append(c)
+            i += 1
+            continue
+        # Found a `_` — could be a literal underscore in the source
+        # qstr (e.g. `__name__`) or the start of `_<name>_` where
+        # `<name>` is an entry in `codepoint2name` (HTML entity name)
+        # or `0xNN` (hex byte literal). Some entity names CONTAIN
+        # underscores themselves: `brace_open`, `brace_close`,
+        # `paren_open`, `bracket_open`, etc. So a naive
+        # `find("_", i+1)` would split `_brace_open_` on the inner
+        # `_` and produce `brace` as the candidate name (which
+        # doesn't match anything, so we'd silently drop the escape).
+        # Iterate forward over EVERY `_` that follows and accept the
+        # first candidate that's a known name (longest valid by
+        # construction — names don't share prefixes that are also
+        # names). Fall back to literal `_` if no closing `_` matches.
+        matched = False
+        j = i + 1
+        while True:
+            k = macro_tail.find("_", j)
+            if k == -1:
+                break
+            candidate = macro_tail[i + 1 : k]
+            if candidate in name2char:
+                out.append(name2char[candidate])
+                i = k + 1
+                matched = True
+                break
+            if (
+                len(candidate) == 4
+                and candidate[:2] == "0x"
+                and all(ch in "0123456789abcdef" for ch in candidate[2:])
+            ):
+                out.append(chr(int(candidate[2:], 16)))
+                i = k + 1
+                matched = True
+                break
+            j = k + 1
+        if not matched:
+            out.append("_")
+            i += 1
+    return "".join(out)
+
+
+def compute_hash(qbytes: bytes, bytes_hash: int) -> int:
+    """djb2 hash, mirrored from upstream `tools/makeqstrdata.py:compute_hash`.
+    Required at `MICROPY_QSTR_BYTES_IN_HASH > 0` (CORE_FEATURES and
+    above): `qstr_find_strn`'s post-binary-search filter does
+    `pool->hashes[at] == str_hash` before memcmp. If the QDEF emits 0
+    for the hash but the runtime computes a real hash, every static
+    lookup misses and `print`/`__name__` NameError at runtime.
+
+    Mirrors upstream's `(hash & mask) or 1` zero-fix; mask width is
+    `8 * bytes_hash`, with `bytes_hash == 0` falling back to a 16-bit
+    mask so the value still fits in `qstr_hash_t = uint16_t` if the
+    port flips to a wider hash."""
+    h = 5381
+    for b in qbytes:
+        h = (h * 33) ^ b
+    mask = (1 << (8 * (bytes_hash or 2))) - 1
+    return (h & mask) or 1
+
+
+def c_string(s: str) -> str:
+    """Render `s` as a C string literal — escape `"`, `\\`, and any
+    byte outside printable ASCII."""
+    parts: list[str] = []
+    for ch in s:
+        b = ord(ch)
+        if ch == "\\":
+            parts.append("\\\\")
+        elif ch == '"':
+            parts.append('\\"')
+        elif ch == "\n":
+            parts.append("\\n")
+        elif ch == "\t":
+            parts.append("\\t")
+        elif ch == "\r":
+            parts.append("\\r")
+        elif 0x20 <= b < 0x7F:
+            parts.append(ch)
+        else:
+            parts.append(f"\\x{b:02x}")
+    return '"' + "".join(parts) + '"'
+
+
+def main() -> int:
+    # Optional `--bytes-hash N` selects the qstr-hash width (matches
+    # `MICROPY_QSTR_BYTES_IN_HASH` in mpconfigport.h). Default 1 ==
+    # CORE_FEATURES; 0 == MINIMUM (hash field is unused at runtime
+    # but we still emit a non-zero value so a future ROM-level bump
+    # works without regenerating qstrdefs).
+    bytes_hash = 1
+    args = sys.argv[1:]
+    i = 0
+    while i < len(args):
+        if args[i] == "--bytes-hash" and i + 1 < len(args):
+            bytes_hash = int(args[i + 1])
+            i += 2
+        else:
+            sys.stderr.write(f"gen_qstrdefs: unknown arg {args[i]!r}\n")
+            return 2
+
+    # Pull the static + unsorted qstr lists from upstream so the
+    # qstrs the runtime needs to fit in a `byte` (e.g. the
+    # mp_binary_op_method_name table at py/objtype.c:483 — entries
+    # like `__add__` are stored as 1-byte qstr ids) end up in the
+    # static (QDEF0) pool with id < 256. Without this, enabling
+    # MICROPY_PY_ALL_SPECIAL_METHODS truncates `MP_QSTR___add__`'s
+    # >256 id to its low byte and `V(2)+V(3)` dispatches to
+    # whatever qstr happens to live at id-modulo-256 (we saw
+    # `FLOAT32` instead of `__add__`).
+    from makeqstrdata import (  # type: ignore[import-not-found]
+        static_qstr_list,
+        unsorted_qstr_list,
+    )
+    static_pool = set(static_qstr_list) | set(unsorted_qstr_list)
+
+    seen: dict[str, str] = {}  # macro -> original
+    for line in sys.stdin:
+        macro = line.strip()
+        if not macro.startswith("MP_QSTR_"):
+            continue
+        if macro in seen:
+            continue
+        # `MP_QSTR_` is 8 chars; the rest is the sanitized qstr.
+        seen[macro] = unescape(macro[8:])
+
+    # Emit QDEF0 entries first (in upstream's defined order) so they
+    # get fixed id slots < 256. Then QDEF1 entries sorted by the
+    # original string (ASCII byte order) — that's the runtime's
+    # binary-search key.
+    out_w = sys.stdout.write
+
+    static_emitted: set[str] = set()
+    # Walk upstream's static_qstr_list verbatim so the .mpy ABI
+    # ID assignments stay stable across uc386 + upstream builds.
+    for original in static_qstr_list:
+        # Find the macro name for this string from `seen`. If our
+        # grep didn't capture it, synthesize the macro: upstream's
+        # qstr_escape can be re-applied via the `unescape` inverse,
+        # but we already have a forward `qstr_escape` in
+        # makeqstrdata, so use that.
+        from makeqstrdata import qstr_escape  # type: ignore
+        macro = "MP_QSTR_" + qstr_escape(original)
+        qhash = compute_hash(original.encode("utf-8"), bytes_hash)
+        out_w(
+            f"QDEF0({macro}, {qhash}, {len(original)}, "
+            f"{c_string(original)})\n"
+        )
+        static_emitted.add(macro)
+
+    # Then unsorted_qstr_list — also QDEF0 (low ids), but ordering
+    # doesn't matter for .mpy compat (these aren't part of the
+    # public ABI list).
+    for original in sorted(unsorted_qstr_list):
+        from makeqstrdata import qstr_escape  # type: ignore
+        macro = "MP_QSTR_" + qstr_escape(original)
+        if macro in static_emitted:
+            continue
+        qhash = compute_hash(original.encode("utf-8"), bytes_hash)
+        out_w(
+            f"QDEF0({macro}, {qhash}, {len(original)}, "
+            f"{c_string(original)})\n"
+        )
+        static_emitted.add(macro)
+
+    # Everything else goes to QDEF1, sorted for the binary-search
+    # invariant.
+    for macro, original in sorted(
+        seen.items(), key=lambda item: (item[1].encode("utf-8"), item[0])
+    ):
+        if macro in static_emitted or original in static_pool:
+            continue
+        qhash = compute_hash(original.encode("utf-8"), bytes_hash)
+        out_w(
+            f"QDEF1({macro}, {qhash}, {len(original)}, "
+            f"{c_string(original)})\n"
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

freedos_micro_python/port/arch/bpstruct.h

@@ -0,0 +1,2 @@
+// Empty pack-struct begin marker — uc_core doesn't pack structs by
+// default and lwIP's wire-shape headers fall through fine without it.

freedos_micro_python/port/arch/cc.h

@@ -0,0 +1,4 @@
+// Stub that forwards to the real arch/cc.h shim (lwip-arch-cc.h).
+// lwIP's headers do `#include "arch/cc.h"`; we put that path on
+// the search list (uc386-dos/) so this file resolves there.
+#include "../lwip-arch-cc.h"

freedos_micro_python/port/arch/epstruct.h

@@ -0,0 +1 @@
+// Empty pack-struct end marker.

freedos_micro_python/port/base64_uc386dos.c

@@ -0,0 +1,164 @@
+// uc386-dos `base64` module — thin port-supplied stdlib shim.
+//
+// MicroPython ships base64 routines in `binascii` (b2a_base64 /
+// a2b_base64) but most CPython programs reach for `import base64;
+// base64.b64encode(...)` directly. Rather than freezing a Python
+// wrapper, we ship a tiny C module with inline RFC 4648 base64 +
+// base16 encoders/decoders. ~80 lines, no allocations beyond the
+// vstr that holds the result.
+//
+// Surface:
+//   base64.b64encode(data)         → bytes (no trailing newline)
+//   base64.b64decode(s)            → bytes
+//   base64.b16encode(data)         → uppercase hex bytes
+//   base64.b16decode(s)            → bytes (case-insensitive accepted)
+
+#include <string.h>
+
+#include "py/runtime.h"
+#include "py/objstr.h"
+#include "py/binary.h"
+
+static const char b64_alphabet[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static int b64_decode_char(int c) {
+    if (c >= 'A' && c <= 'Z') return c - 'A';
+    if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+    if (c >= '0' && c <= '9') return c - '0' + 52;
+    if (c == '+') return 62;
+    if (c == '/') return 63;
+    return -1;  // invalid (also catches '=' padding)
+}
+
+static mp_obj_t base64_b64encode(mp_obj_t data_in) {
+    mp_buffer_info_t buf;
+    mp_get_buffer_raise(data_in, &buf, MP_BUFFER_READ);
+    const unsigned char *src = (const unsigned char *)buf.buf;
+    size_t n = buf.len;
+
+    vstr_t vstr;
+    vstr_init_len(&vstr, ((n + 2) / 3) * 4);
+    char *out = vstr.buf;
+
+    size_t i = 0;
+    for (; i + 3 <= n; i += 3) {
+        unsigned int v = ((unsigned int)src[i] << 16) |
+                         ((unsigned int)src[i + 1] << 8) |
+                         (unsigned int)src[i + 2];
+        *out++ = b64_alphabet[(v >> 18) & 0x3F];
+        *out++ = b64_alphabet[(v >> 12) & 0x3F];
+        *out++ = b64_alphabet[(v >> 6) & 0x3F];
+        *out++ = b64_alphabet[v & 0x3F];
+    }
+    size_t rem = n - i;
+    if (rem == 1) {
+        unsigned int v = (unsigned int)src[i] << 16;
+        *out++ = b64_alphabet[(v >> 18) & 0x3F];
+        *out++ = b64_alphabet[(v >> 12) & 0x3F];
+        *out++ = '=';
+        *out++ = '=';
+    } else if (rem == 2) {
+        unsigned int v = ((unsigned int)src[i] << 16) |
+                         ((unsigned int)src[i + 1] << 8);
+        *out++ = b64_alphabet[(v >> 18) & 0x3F];
+        *out++ = b64_alphabet[(v >> 12) & 0x3F];
+        *out++ = b64_alphabet[(v >> 6) & 0x3F];
+        *out++ = '=';
+    }
+    return mp_obj_new_bytes_from_vstr(&vstr);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(base64_b64encode_obj, base64_b64encode);
+
+static mp_obj_t base64_b64decode(mp_obj_t s_in) {
+    mp_buffer_info_t buf;
+    mp_get_buffer_raise(s_in, &buf, MP_BUFFER_READ);
+    const unsigned char *src = (const unsigned char *)buf.buf;
+    size_t n = buf.len;
+
+    vstr_t vstr;
+    vstr_init(&vstr, (n * 3) / 4 + 4);
+    int bits = 0;
+    int collected = 0;
+    for (size_t i = 0; i < n; i++) {
+        int c = src[i];
+        if (c == '\r' || c == '\n' || c == ' ' || c == '\t') {
+            continue;
+        }
+        if (c == '=') {
+            break;  // padding — no more data
+        }
+        int v = b64_decode_char(c);
+        if (v < 0) {
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid base64 character"));
+        }
+        bits = (bits << 6) | v;
+        collected += 6;
+        if (collected >= 8) {
+            collected -= 8;
+            vstr_add_byte(&vstr, (bits >> collected) & 0xFF);
+        }
+    }
+    return mp_obj_new_bytes_from_vstr(&vstr);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(base64_b64decode_obj, base64_b64decode);
+
+static mp_obj_t base64_b16encode(mp_obj_t data_in) {
+    mp_buffer_info_t buf;
+    mp_get_buffer_raise(data_in, &buf, MP_BUFFER_READ);
+    const unsigned char *src = (const unsigned char *)buf.buf;
+    static const char hex[] = "0123456789ABCDEF";
+
+    vstr_t vstr;
+    vstr_init_len(&vstr, buf.len * 2);
+    char *out = vstr.buf;
+    for (size_t i = 0; i < buf.len; i++) {
+        *out++ = hex[(src[i] >> 4) & 0x0F];
+        *out++ = hex[src[i] & 0x0F];
+    }
+    return mp_obj_new_bytes_from_vstr(&vstr);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(base64_b16encode_obj, base64_b16encode);
+
+static int hex_digit(int c) {
+    if (c >= '0' && c <= '9') return c - '0';
+    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+    return -1;
+}
+
+static mp_obj_t base64_b16decode(mp_obj_t s_in) {
+    mp_buffer_info_t buf;
+    mp_get_buffer_raise(s_in, &buf, MP_BUFFER_READ);
+    const unsigned char *src = (const unsigned char *)buf.buf;
+    if (buf.len & 1) {
+        mp_raise_ValueError(MP_ERROR_TEXT("odd-length base16 input"));
+    }
+    vstr_t vstr;
+    vstr_init_len(&vstr, buf.len / 2);
+    char *out = vstr.buf;
+    for (size_t i = 0; i < buf.len; i += 2) {
+        int hi = hex_digit(src[i]);
+        int lo = hex_digit(src[i + 1]);
+        if (hi < 0 || lo < 0) {
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid base16 character"));
+        }
+        *out++ = (hi << 4) | lo;
+    }
+    return mp_obj_new_bytes_from_vstr(&vstr);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(base64_b16decode_obj, base64_b16decode);
+
+static const mp_rom_map_elem_t mp_module_base64_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__),  MP_ROM_QSTR(MP_QSTR_base64) },
+    { MP_ROM_QSTR(MP_QSTR_b64encode), MP_ROM_PTR(&base64_b64encode_obj) },
+    { MP_ROM_QSTR(MP_QSTR_b64decode), MP_ROM_PTR(&base64_b64decode_obj) },
+    { MP_ROM_QSTR(MP_QSTR_b16encode), MP_ROM_PTR(&base64_b16encode_obj) },
+    { MP_ROM_QSTR(MP_QSTR_b16decode), MP_ROM_PTR(&base64_b16decode_obj) },
+};
+static MP_DEFINE_CONST_DICT(mp_module_base64_globals, mp_module_base64_globals_table);
+
+const mp_obj_module_t mp_module_base64 = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&mp_module_base64_globals,
+};