PyPI - struct2ui - Versions diffs - 0.1.0__py3-none-any.whl - Mend

struct2ui 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

struct2ui/__init__.py +4 -0
struct2ui/editor.py +1171 -0
struct2ui/exporters/__init__.py +15 -0
struct2ui/exporters/bin_emitter.py +254 -0
struct2ui/exporters/c_emitter.py +233 -0
struct2ui/exporters/c_parser.py +204 -0
struct2ui/exporters/elf_verifier.py +341 -0
struct2ui/exporters/json_format.py +137 -0
struct2ui/icons/c2j.png +0 -0
struct2ui/icons/elf.png +0 -0
struct2ui/icons/export_notes_24dp_000000_FILL0_wght400_GRAD0_opsz24.png +0 -0
struct2ui/icons/flowchart_24dp_000000_FILL0_wght400_GRAD0_opsz24.png +0 -0
struct2ui/icons/refresh_24dp_000000_FILL0_wght400_GRAD0_opsz24.png +0 -0
struct2ui/icons/report_24dp_000000_FILL0_wght400_GRAD0_opsz24.png +0 -0
struct2ui/icons/save_24dp_000000_FILL0_wght400_GRAD0_opsz24.png +0 -0
struct2ui/icons/save_as_24dp_000000_FILL0_wght400_GRAD0_opsz24.png +0 -0
struct2ui/icons/settings_24dp_000000_FILL0_wght400_GRAD0_opsz24.png +0 -0
struct2ui/icons/widgets_24dp_000000_FILL0_wght400_GRAD0_opsz24.png +0 -0
struct2ui/schema.py +1118 -0
struct2ui/ui/__init__.py +36 -0
struct2ui/ui/renderers.py +304 -0
struct2ui/ui/tables.py +207 -0
struct2ui/ui/widgets.py +907 -0
struct2ui-0.1.0.dist-info/METADATA +167 -0
struct2ui-0.1.0.dist-info/RECORD +28 -0
struct2ui-0.1.0.dist-info/WHEEL +5 -0
struct2ui-0.1.0.dist-info/licenses/LICENSE +21 -0
struct2ui-0.1.0.dist-info/top_level.txt +1 -0

struct2ui/exporters/c_parser.py ADDED Viewed

@@ -0,0 +1,204 @@
+"""C source -> cfg_t-style schema dict (the reverse of the JSON->UI flow).
+Pure data, no Qt. Single responsibility: scan a .c/.h file with simple regex
+lexing and produce a dict shaped exactly like the existing cfg_t/*.json files
+(see cfg_t/a_cfg_t.json for the target shape).
+Supported constructs (deliberately limited; the project restricts macro use):
+  - simple `#define NAME VALUE`        -> top-level int/float const
+  - `typedef enum { A=0, B, } name_t;` -> {"type":"enum","items":{...}}
+  - `typedef struct { ... } name_t;`   -> {"type":"struct","items":[...]}
+Inside a struct, each member line `type name;`, `type name[N];` or
+`type name[N][M];` becomes a field spec. char[N] keeps `count` so the schema
+layer recognises it as a string; other arrays keep `count` (or a `count` list
+for multi-dimensional arrays, matching how shapes flatten elsewhere).
+Anything the regex cannot classify is collected as a warning so the caller can
+surface it instead of silently dropping members.
+"""
+from __future__ import annotations
+import re
+from typing import Any, Dict, List, Tuple
+# Strip // line comments and /* ... */ block comments before lexing.
+_LINE_COMMENT = re.compile(r'//[^\n]*')
+_BLOCK_COMMENT = re.compile(r'/\*.*?\*/', re.DOTALL)
+# #define NAME VALUE  (only simple object-like macros; function-like macros,
+# i.e. `#define F(x) ...`, are skipped).
+_DEFINE = re.compile(
+    r'^[ \t]*#[ \t]*define[ \t]+([A-Za-z_]\w*)[ \t]+(.+?)[ \t]*$',
+    re.MULTILINE,
+)
+# typedef enum { body } name ;
+_ENUM = re.compile(
+    r'typedef\s+enum\s*(?:[A-Za-z_]\w*\s*)?\{(?P<body>.*?)\}\s*'
+    r'(?P<name>[A-Za-z_]\w*)\s*;',
+    re.DOTALL,
+)
+# typedef struct { body } name ;
+_STRUCT = re.compile(
+    r'typedef\s+struct\s*(?:[A-Za-z_]\w*\s*)?\{(?P<body>.*?)\}\s*'
+    r'(?P<name>[A-Za-z_]\w*)\s*;',
+    re.DOTALL,
+)
+# One struct member: optional `const`, a type (one or more words to allow
+# `unsigned int`), a name, optional [..] dimensions, trailing `;`.
+_MEMBER = re.compile(
+    r'^\s*(?:const\s+)?'
+    r'(?P<type>(?:struct\s+)?[A-Za-z_]\w*(?:\s+[A-Za-z_]\w*)*?)\s+'
+    r'(?P<name>[A-Za-z_]\w*)\s*'
+    r'(?P<dims>(?:\[[^\]]*\])*)\s*;\s*$'
+)
+_DIM = re.compile(r'\[([^\]]*)\]')
+class CParseResult:
+    """Container for one parse pass: the schema dict plus collected warnings."""
+    def __init__(self) -> None:
+        self.schema: Dict[str, Any] = {}
+        self.consts: Dict[str, Any] = {}
+        self.warnings: List[str] = []
+    @property
+    def has_content(self) -> bool:
+        return bool(self.schema) or bool(self.consts)
+def _strip_comments(text: str) -> str:
+    text = _BLOCK_COMMENT.sub(' ', text)
+    text = _LINE_COMMENT.sub('', text)
+    return text
+def _parse_define_value(raw: str) -> Any:
+    """Best-effort numeric value of a simple #define. Returns None if it is
+    not a plain int/float (e.g. an expression or another macro)."""
+    token = raw.strip()
+    # Allow a single set of wrapping parentheses: `#define N (40)`.
+    if token.startswith('(') and token.endswith(')'):
+        token = token[1:-1].strip()
+    # Drop integer suffixes like 40U, 40UL, 1.0f.
+    int_match = re.fullmatch(r'[+-]?\d+[uUlL]*', token)
+    if int_match:
+        return int(re.sub(r'[uUlL]+$', '', token))
+    float_match = re.fullmatch(r'[+-]?\d*\.\d+[fF]?|[+-]?\d+\.\d*[fF]?', token)
+    if float_match:
+        return float(token.rstrip('fF'))
+    return None
+def _parse_defines(text: str, result: CParseResult) -> None:
+    for name, raw in _DEFINE.findall(text):
+        # Skip function-like macros: `#define F (x)` would have raw "(x)" but
+        # the real giveaway is `NAME(` with no space, which the regex above
+        # already excludes by requiring whitespace before the value. A value
+        # we cannot reduce to a number is recorded as a warning.
+        value = _parse_define_value(raw)
+        if value is None:
+            result.warnings.append(
+                f"#define {name}: value '{raw}' is not a plain number; skipped")
+            continue
+        result.consts[name] = value
+def _parse_enums(text: str, result: CParseResult) -> None:
+    for m in _ENUM.finditer(text):
+        name = m.group('name')
+        items: Dict[str, int] = {}
+        next_value = 0
+        for entry in m.group('body').split(','):
+            entry = entry.strip()
+            if not entry:
+                continue
+            if '=' in entry:
+                key, _, val = entry.partition('=')
+                key = key.strip()
+                val = val.strip()
+                parsed = _parse_define_value(val)
+                if parsed is None or not isinstance(parsed, int):
+                    parsed = result.consts.get(val)
+                if not isinstance(parsed, int):
+                    result.warnings.append(
+                        f"enum {name}: cannot resolve value of '{key} = {val}'")
+                    next_value += 1
+                    continue
+                next_value = parsed
+            else:
+                key = entry
+            items[key] = next_value
+            next_value += 1
+        result.schema[name] = {'type': 'enum', 'items': items}
+def _parse_member(line: str) -> Tuple[Dict[str, Any], str]:
+    """Parse one struct member line. Returns (field_spec, '') on success or
+    ({}, reason) on failure."""
+    m = _MEMBER.match(line)
+    if not m:
+        return {}, f"unrecognized member: '{line.strip()}'"
+    ctype = re.sub(r'\s+', ' ', m.group('type')).strip()
+    fname = m.group('name')
+    dims = _DIM.findall(m.group('dims') or '')
+    field: Dict[str, Any] = {'name': fname, 'type': ctype}
+    if dims:
+        counts: List[Any] = []
+        for d in dims:
+            d = d.strip()
+            num = _parse_define_value(d)
+            counts.append(num if num is not None else d)
+        field['count'] = counts[0] if len(counts) == 1 else counts
+    return field, ''
+def _parse_structs(text: str, result: CParseResult) -> None:
+    for m in _STRUCT.finditer(text):
+        name = m.group('name')
+        body = m.group('body')
+        items: List[Dict[str, Any]] = []
+        # Split on ';' so members spanning whitespace/newlines stay together.
+        for chunk in body.split(';'):
+            chunk = chunk.strip()
+            if not chunk:
+                continue
+            field, reason = _parse_member(chunk + ';')
+            if reason:
+                result.warnings.append(f"struct {name}: {reason}")
+                continue
+            items.append(field)
+        result.schema[name] = {'type': 'struct', 'items': items}
+def parse_c_source(text: str) -> CParseResult:
+    """Parse C source text into a cfg_t-style schema result."""
+    result = CParseResult()
+    clean = _strip_comments(text)
+    _parse_defines(clean, result)
+    _parse_enums(clean, result)
+    _parse_structs(clean, result)
+    return result
+def build_schema_dict(result: CParseResult) -> Dict[str, Any]:
+    """Merge consts + enums + structs into one ordered cfg_t-style dict,
+    matching the layout of the hand-written cfg_t/*.json files (consts and
+    enums first, then structs)."""
+    out: Dict[str, Any] = {}
+    for k, v in result.consts.items():
+        out[k] = v
+    for k, v in result.schema.items():
+        if v.get('type') == 'enum':
+            out[k] = v
+    for k, v in result.schema.items():
+        if v.get('type') == 'struct':
+            out[k] = v
+    return out

struct2ui/exporters/elf_verifier.py ADDED Viewed

@@ -0,0 +1,341 @@
+"""ELF/DWARF layout verifier: compares the schema-derived C-ABI layout of
+each pipeline cfg struct against the ground-truth layout recorded in an ELF's
+DWARF debug info.
+Strictest policy (all mismatches are errors):
+  - member name + order must match exactly
+  - each member's byte offset must match
+  - each member's byte size must match
+  - the struct's total byte size must match
+Type names are matched against DWARF as-is: a stage's `type` (e.g. "a_cfg_t")
+is looked up among the ELF's struct/typedef names verbatim. A type not found
+in the ELF is an error.
+No Qt here; the verifier returns a LoadReport so the UI can render it with the
+same panels used for cfg_t / pipeline issues.
+"""
+from __future__ import annotations
+import os
+from typing import Any, Dict, List, Optional, Tuple
+from ..schema import (
+    Field, ScalarField, EnumField, StructField, ArrayField,
+    SchemaRegistry, LoadReport,
+)
+from .bin_emitter import _alignof, _sizeof, merge_abi
+# --------------------------------------------------------------------------- #
+# DWARF model
+# --------------------------------------------------------------------------- #
+class DwarfMember:
+    __slots__ = ('name', 'offset', 'size')
+    def __init__(self, name: str, offset: int, size: int) -> None:
+        self.name = name
+        self.offset = offset
+        self.size = size
+class DwarfStruct:
+    __slots__ = ('name', 'byte_size', 'members')
+    def __init__(self, name: Optional[str], byte_size: int,
+                 members: List[DwarfMember]) -> None:
+        self.name = name
+        self.byte_size = byte_size
+        self.members = members
+class ElfLayout:
+    """A lookup of type-name -> DwarfStruct parsed from one ELF file."""
+    def __init__(self, structs: Dict[str, DwarfStruct]) -> None:
+        self._structs = structs
+    def get(self, type_name: str) -> Optional[DwarfStruct]:
+        return self._structs.get(type_name)
+    def __contains__(self, type_name: str) -> bool:
+        return type_name in self._structs
+# --------------------------------------------------------------------------- #
+# DWARF parsing
+# --------------------------------------------------------------------------- #
+def load_elf_layout(elf_path: str,
+                    wanted: Optional[set] = None) -> ElfLayout:
+    """Parse the ELF's DWARF and index named structs (and typedefs that point
+    at structs) by name. Raises on parse failure; callers turn that into a
+    LoadReport error.
+    Only top-level DIEs of each compilation unit are scanned, which is where
+    cfg structs / typedefs live; this avoids walking every nested DIE in a
+    large firmware ELF (orders of magnitude faster). When `wanted` is given,
+    iteration stops as soon as every wanted name has been indexed.
+    """
+    from elftools.elf.elffile import ELFFile  # lazy: optional dependency
+    structs: Dict[str, DwarfStruct] = {}
+    with open(elf_path, 'rb') as f:
+        elf = ELFFile(f)
+        if not elf.has_dwarf_info():
+            raise ValueError('ELF has no DWARF debug info')
+        dwarf = elf.get_dwarf_info()
+        for cu in dwarf.iter_CUs():
+            top = cu.get_top_DIE()
+            for die in top.iter_children():
+                name = _die_name(die)
+                if not name:
+                    continue
+                if die.tag == 'DW_TAG_structure_type':
+                    structs.setdefault(name, _parse_struct(cu, die))
+                elif die.tag == 'DW_TAG_typedef':
+                    target = _resolve_to_struct(cu, die)
+                    if target is not None:
+                        structs.setdefault(name, _parse_struct(cu, target))
+            if wanted and wanted.issubset(structs.keys()):
+                break
+    return ElfLayout(structs)
+def _die_name(die) -> Optional[str]:
+    attr = die.attributes.get('DW_AT_name')
+    if attr is None:
+        return None
+    val = attr.value
+    return val.decode(errors='replace') if isinstance(val, bytes) else str(val)
+def _deref_type(cu, die):
+    attr = die.attributes.get('DW_AT_type')
+    if attr is None:
+        return None
+    return cu.get_DIE_from_refaddr(attr.value + cu.cu_offset)
+def _strip_cv_typedef(cu, die):
+    """Follow typedef / const / volatile wrappers to the underlying type."""
+    seen = 0
+    while die is not None and seen < 32:
+        if die.tag in ('DW_TAG_typedef', 'DW_TAG_const_type',
+                       'DW_TAG_volatile_type'):
+            die = _deref_type(cu, die)
+            seen += 1
+            continue
+        return die
+    return die
+def _resolve_to_struct(cu, die):
+    target = _strip_cv_typedef(cu, _deref_type(cu, die))
+    if target is not None and target.tag == 'DW_TAG_structure_type':
+        return target
+    return None
+def _parse_struct(cu, die) -> DwarfStruct:
+    byte_size = _attr_int(die, 'DW_AT_byte_size', 0)
+    members: List[DwarfMember] = []
+    for child in die.iter_children():
+        if child.tag != 'DW_TAG_member':
+            continue
+        name = _die_name(child) or '<anon>'
+        offset = _attr_int(child, 'DW_AT_data_member_location', 0)
+        size = _member_byte_size(cu, child)
+        members.append(DwarfMember(name, offset, size))
+    return DwarfStruct(_die_name(die), byte_size, members)
+def _attr_int(die, key: str, default: int) -> int:
+    attr = die.attributes.get(key)
+    if attr is None:
+        return default
+    val = attr.value
+    if isinstance(val, list):  # location expression form; ignore, rare here
+        return default
+    return int(val)
+def _member_byte_size(cu, member) -> int:
+    """Byte size of a member, following its type chain.
+    For an array, multiply the element size by every dimension's count so the
+    result is the full in-struct footprint (matching the schema side, which
+    reports the whole array as one member).
+    """
+    type_die = _deref_type(cu, member)
+    return _type_byte_size(cu, type_die)
+def _type_byte_size(cu, die) -> int:
+    seen = 0
+    while die is not None and seen < 64:
+        size_attr = die.attributes.get('DW_AT_byte_size')
+        if die.tag == 'DW_TAG_array_type':
+            elem = _strip_cv_typedef(cu, _deref_type(cu, die))
+            elem_size = _type_byte_size(cu, elem)
+            count = 1
+            for sub in die.iter_children():
+                if sub.tag == 'DW_TAG_subrange_type':
+                    ub = sub.attributes.get('DW_AT_upper_bound')
+                    cnt = sub.attributes.get('DW_AT_count')
+                    if cnt is not None:
+                        count *= int(cnt.value)
+                    elif ub is not None:
+                        count *= int(ub.value) + 1
+            return elem_size * count
+        if size_attr is not None:
+            return int(size_attr.value)
+        nxt = _deref_type(cu, die)
+        if nxt is None:
+            return 0
+        die = nxt
+        seen += 1
+    return 0
+# --------------------------------------------------------------------------- #
+# Schema-side layout (mirrors the C-ABI offsets the bin emitter would use)
+# --------------------------------------------------------------------------- #
+class SchemaMember:
+    __slots__ = ('name', 'offset', 'size')
+    def __init__(self, name: str, offset: int, size: int) -> None:
+        self.name = name
+        self.offset = offset
+        self.size = size
+def schema_struct_layout(node: StructField,
+                         abi: Dict[str, Any]) -> Tuple[int, List[SchemaMember]]:
+    """Compute (total_size, members) for a StructField using the same C-ABI
+    rules as the .bin emitter (natural alignment, pack cap, tail padding).
+    """
+    members: List[SchemaMember] = []
+    offset = 0
+    for child in node.children:
+        align = _alignof(child, abi)
+        rem = offset % align
+        if rem:
+            offset += align - rem
+        size = _sizeof(child, abi)
+        members.append(SchemaMember(child.name, offset, size))
+        offset += size
+    struct_align = _alignof(node, abi)
+    rem = offset % struct_align
+    if rem:
+        offset += struct_align - rem
+    return offset, members
+# --------------------------------------------------------------------------- #
+# Comparison
+# --------------------------------------------------------------------------- #
+def verify_sections(sections, registry: SchemaRegistry, elf_path: str,
+                    abi: Optional[Dict[str, Any]] = None) -> LoadReport:
+    """Verify every section's cfg struct against the ELF DWARF layout.
+    `sections` is a sequence of (label, type_name, values); only label and
+    type_name are used. Each distinct type_name is verified once. Returns a
+    LoadReport whose `file` is the ELF path so the UI panels stay uniform.
+    """
+    report = LoadReport()
+    if not elf_path:
+        return report
+    elf_label = os.path.basename(elf_path) or elf_path
+    if not os.path.exists(elf_path):
+        report.error(elf_label, '', f'ELF file not found: {elf_path}')
+        return report
+    wanted = {t for _l, t, _v in sections if t}
+    try:
+        layout = load_elf_layout(elf_path, wanted)
+    except ImportError:
+        report.error(
+            elf_label, '',
+            'pyelftools is required for ELF verification (pip install pyelftools)')
+        return report
+    except Exception as exc:  # noqa: BLE001 - surface any parse failure
+        report.error(elf_label, '', f'failed to read DWARF: {exc}')
+        return report
+    abi = abi if abi is not None else merge_abi(None)
+    seen: set = set()
+    for _label, type_name, _values in sections:
+        if not type_name or type_name in seen:
+            continue
+        seen.add(type_name)
+        _verify_type(report, registry, layout, type_name, elf_label, abi)
+    return report
+def _verify_type(report: LoadReport, registry: SchemaRegistry,
+                 layout: ElfLayout, type_name: str, elf_label: str,
+                 abi: Dict[str, Any]) -> None:
+    dwarf = layout.get(type_name)
+    if dwarf is None:
+        report.error(
+            elf_label, type_name,
+            f"type '{type_name}' not found in ELF DWARF")
+        return
+    root = registry.build(type_name)
+    total, members = schema_struct_layout(root, abi)
+    # Total struct size.
+    if total != dwarf.byte_size:
+        report.error(
+            elf_label, type_name,
+            f"struct size mismatch: schema {total} bytes, "
+            f"ELF {dwarf.byte_size} bytes")
+    # Member count / name+order, walked position by position so we can report
+    # the first divergence precisely without masking later members.
+    n = max(len(members), len(dwarf.members))
+    for i in range(n):
+        sm = members[i] if i < len(members) else None
+        dm = dwarf.members[i] if i < len(dwarf.members) else None
+        loc = f'{type_name}[{i}]'
+        if sm is None:
+            report.error(
+                elf_label, loc,
+                f"ELF has extra member '{dm.name}' "
+                f"(offset {dm.offset}, size {dm.size}) "
+                f"not present in schema")
+            continue
+        if dm is None:
+            report.error(
+                elf_label, f'{type_name} -> {sm.name}',
+                f"schema member '{sm.name}' has no matching member in ELF")
+            continue
+        if sm.name != dm.name:
+            report.error(
+                elf_label, loc,
+                f"member name/order mismatch: schema '{sm.name}', "
+                f"ELF '{dm.name}'")
+            # Names diverged: positional offset/size comparison would be
+            # noise, so move on to the next position.
+            continue
+        member_loc = f'{type_name} -> {sm.name}'
+        if sm.offset != dm.offset:
+            report.error(
+                elf_label, member_loc,
+                f"offset mismatch: schema {sm.offset}, ELF {dm.offset}")
+        if sm.size != dm.size:
+            report.error(
+                elf_label, member_loc,
+                f"size mismatch: schema {sm.size} bytes, "
+                f"ELF {dm.size} bytes")

struct2ui/exporters/json_format.py ADDED Viewed

@@ -0,0 +1,137 @@
+"""Pretty-print a pipeline document as JSON with .c-style compaction.
+Structural heuristic (no schema needed):
+  - A list of scalars        -> single line: [1, 2, 3]
+  - A list of dicts          -> one dict per line, each dict on a single line
+  - Anything else (dict, or  -> normal indented expansion
+    mixed/nested lists)
+The dict-per-line rule mirrors how table widgets render struct arrays in the
+exported .c, keeping the saved JSON readable for the same data.
+Optional schema-aware multi-line wrapping:
+  Callers may pass `wrap_resolver`, a function (path) -> int that, given the
+  JSON path to a scalar list (a tuple of dict keys / list indices from the
+  document root), returns how many values to place per line (0 = single line).
+  This lets `widget=multiline` arrays save as line-broken blocks while the
+  printer itself stays schema-agnostic.
+"""
+from __future__ import annotations
+import json
+from typing import Any, Callable, Optional, Tuple
+INDENT = '  '
+# Wrap scalar lists longer than this many elements onto multiple lines, even
+# without an explicit widget=multiline hint. Keeps saved JSON readable.
+MAX_ROW = 64
+WrapResolver = Callable[[Tuple[Any, ...]], int]
+def dumps(data: Any, wrap_resolver: Optional[WrapResolver] = None) -> str:
+    return _emit(data, 0, (), wrap_resolver) + '\n'
+def _emit(value: Any, level: int, path: Tuple[Any, ...],
+          wrap: Optional[WrapResolver]) -> str:
+    if isinstance(value, dict):
+        return _emit_dict(value, level, path, wrap)
+    if isinstance(value, list):
+        return _emit_list(value, level, path, wrap)
+    return _scalar(value)
+def _emit_dict(obj: dict, level: int, path: Tuple[Any, ...],
+               wrap: Optional[WrapResolver]) -> str:
+    if not obj:
+        return '{}'
+    pad = INDENT * (level + 1)
+    close = INDENT * level
+    lines = [
+        f'{pad}{json.dumps(k, ensure_ascii=False)}: '
+        f'{_emit(v, level + 1, path + (k,), wrap)}'
+        for k, v in obj.items()
+    ]
+    return '{\n' + ',\n'.join(lines) + f'\n{close}}}'
+def _emit_list(arr: list, level: int, path: Tuple[Any, ...],
+               wrap: Optional[WrapResolver]) -> str:
+    if not arr:
+        return '[]'
+    if all(_is_scalar(x) for x in arr):
+        row_size = wrap(path) if wrap is not None else 0
+        if not (row_size and row_size > 0) and len(arr) > MAX_ROW:
+            row_size = MAX_ROW
+        if row_size and row_size > 0 and len(arr) > row_size:
+            return _emit_wrapped_scalars(arr, level, row_size)
+        return '[' + ', '.join(_scalar(x) for x in arr) + ']'
+    if all(isinstance(x, dict) for x in arr):
+        pad = INDENT * (level + 1)
+        close = INDENT * level
+        rows = _compact_dicts_aligned(arr, pad)
+        return '[\n' + ',\n'.join(rows) + f'\n{close}]'
+    pad = INDENT * (level + 1)
+    close = INDENT * level
+    rows = [pad + _emit(x, level + 1, path + (i,), wrap)
+            for i, x in enumerate(arr)]
+    return '[\n' + ',\n'.join(rows) + f'\n{close}]'
+def _emit_wrapped_scalars(arr: list, level: int, row_size: int) -> str:
+    pad = INDENT * (level + 1)
+    close = INDENT * level
+    cells = [_scalar(x) for x in arr]
+    grid = [cells[i:i + row_size] for i in range(0, len(cells), row_size)]
+    widths = [max((len(row[j]) for row in grid if j < len(row)), default=0)
+              for j in range(row_size)]
+    rows = []
+    for row in grid:
+        padded = [c.ljust(widths[j]) for j, c in enumerate(row)]
+        rows.append(pad + ', '.join(padded).rstrip())
+    return '[\n' + ',\n'.join(rows) + f'\n{close}]'
+def _compact_dicts_aligned(arr: list, pad: str) -> list:
+    """One compact dict per line. When every dict has the same keys in the
+    same order (i.e. a table), pad each column so values line up vertically.
+    """
+    keyseqs = [tuple(x.keys()) for x in arr]
+    uniform = len(arr) > 1 and len(set(keyseqs)) == 1
+    if not uniform:
+        return [pad + _compact_dict(x) for x in arr]
+    keys = keyseqs[0]
+    cols = [[f'{json.dumps(k, ensure_ascii=False)}: {_compact(x[k])}' for k in keys]
+            for x in arr]
+    widths = [max(len(row[j]) for row in cols) for j in range(len(keys))]
+    rows = []
+    for row in cols:
+        cells = [c.ljust(widths[j]) for j, c in enumerate(row)]
+        rows.append(pad + '{' + ', '.join(cells).rstrip() + '}')
+    return rows
+def _compact_dict(obj: dict) -> str:
+    parts = [f'{json.dumps(k, ensure_ascii=False)}: {_compact(v)}'
+             for k, v in obj.items()]
+    return '{' + ', '.join(parts) + '}'
+def _compact(value: Any) -> str:
+    if isinstance(value, dict):
+        return _compact_dict(value)
+    if isinstance(value, list):
+        return '[' + ', '.join(_compact(x) for x in value) + ']'
+    return _scalar(value)
+def _is_scalar(value: Any) -> bool:
+    return not isinstance(value, (dict, list))
+def _scalar(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False)