multilingualprogramming 0.7.0__tar.gz → 0.8.0__tar.gz

{multilingualprogramming-0.7.0 → multilingualprogramming-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multilingualprogramming
-Version: 0.7.0
+Version: 0.8.0
 Summary: Python application for multilingual programming
 Author-email: John Samuel <johnsamuelwrites@example.com>
 License-Expression: GPL-3.0-or-later

{multilingualprogramming-0.7.0 → multilingualprogramming-0.8.0}/multilingualprogramming/__main__.py

@@ -49,6 +49,16 @@ from multilingualprogramming.source_extensions import (
     find_package_init,
     has_source_extension,
 )
+from multilingualprogramming.codegen.linear_manifest import build_linear_manifest_file
+from multilingualprogramming.codegen.midi_manifest import build_midi_manifest_file
+from multilingualprogramming.codegen.opcode_ontology import write_ontology_manifest
+from multilingualprogramming.codegen.semantic_core import build_semantic_core_file
+from multilingualprogramming.codegen.process_program import build_process_core_file
+from multilingualprogramming.codegen.sonic_projection import build_sonic_manifest_file
+from multilingualprogramming.codegen.spatial_manifest import build_spatial_manifest_file
+from multilingualprogramming.codegen.volumetric_manifest import (
+    build_volumetric_manifest_file,
+)
 from multilingualprogramming.version import __version__
 
 
@@ -367,6 +377,101 @@ def cmd_build_ui_bundle(args):
             print(f"[WARN] {diag}")
 
 
+def cmd_spatial_build(args):
+    """Build a spatial JSON manifest from a Multilingual source file."""
+    manifest = build_spatial_manifest_file(
+        args.file,
+        args.out,
+        language=args.lang or "en",
+    )
+    print(f"[PASS] {args.out}")
+    print(f"[spatial] {manifest['kind']} entities={len(manifest['entities'])}")
+
+
+def cmd_polymodal_build(args):
+    """Build a modality-free semantic core manifest from Multilingual source."""
+    core = build_semantic_core_file(
+        args.file,
+        args.out,
+        language=args.lang or "en",
+    )
+    print(f"[PASS] {args.out}")
+    print(f"[polymodal] {core['kind']} entities={len(core['entities'])}")
+
+
+def cmd_process_build(args):
+    """Build a semantic-core-v1 process manifest from Multilingual source."""
+    core = build_process_core_file(
+        args.file,
+        args.out,
+        language=args.lang or "en",
+    )
+    state = core.get("state", {})
+    # A lattice program stores loci; a sequence (string-rewriting) program
+    # stores an ordered sequence. Report whichever this core carries.
+    if "sequence" in state:
+        size = f"symbols={len(state['sequence'])}"
+    else:
+        size = f"loci={len(state.get('loci', []))}"
+    print(f"[PASS] {args.out}")
+    print(
+        f"[process] {core['kind']} "
+        f"topology={core['topology'].get('kind')} "
+        f"schedule={core['schedule'].get('kind')} {size}"
+    )
+
+
+def cmd_sonic_build(args):
+    """Build a sonic JSON manifest from a Multilingual source file."""
+    manifest = build_sonic_manifest_file(
+        args.file,
+        args.out,
+        language=args.lang or "en",
+    )
+    print(f"[PASS] {args.out}")
+    print(f"[sonic] {manifest['kind']} voices={len(manifest['voices'])}")
+
+
+def cmd_ontology_export(args):
+    """Write the shared opcode ontology as JSON for browser runtimes."""
+    manifest = write_ontology_manifest(args.out)
+    print(f"[PASS] {args.out}")
+    print(f"[ontology] {manifest['kind']} opcodes={len(manifest['opcodes'])}")
+
+
+def cmd_linear_build(args):
+    """Build a 1D linear JSON manifest from a Multilingual source file."""
+    manifest = build_linear_manifest_file(
+        args.file,
+        args.out,
+        language=args.lang or "en",
+    )
+    print(f"[PASS] {args.out}")
+    print(f"[linear] {manifest['kind']} marks={len(manifest['marks'])}")
+
+
+def cmd_volumetric_build(args):
+    """Build a 3D volumetric JSON manifest from a Multilingual source file."""
+    manifest = build_volumetric_manifest_file(
+        args.file,
+        args.out,
+        language=args.lang or "en",
+    )
+    print(f"[PASS] {args.out}")
+    print(f"[volumetric] {manifest['kind']} marks={len(manifest['marks'])}")
+
+
+def cmd_midi_build(args):
+    """Build a MIDI JSON manifest from a Multilingual source file."""
+    manifest = build_midi_manifest_file(
+        args.file,
+        args.out,
+        language=args.lang or "en",
+    )
+    print(f"[PASS] {args.out}")
+    print(f"[midi] {manifest['kind']} events={len(manifest['events'])}")
+
+
 def cmd_ir(args):
     """Lower a source file to semantic IR and print a summary."""
     program = _parse_program_from_file(args.file, args.lang)
@@ -576,7 +681,7 @@ def _maybe_dispatch_direct_file_run(argv):
     return True
 
 
-def main():  # pylint: disable=too-many-statements
+def main():  # pylint: disable=too-many-statements,too-many-locals,too-many-branches
     """Run the CLI entry point and dispatch subcommands."""
     argv = sys.argv[1:]
     if _maybe_dispatch_direct_file_run(argv):
@@ -739,6 +844,113 @@ def main():  # pylint: disable=too-many-statements
         help="Output directory for generated artifacts (default: build/ui)",
     )
 
+    spatial_build_parser = subparsers.add_parser(
+        "spatial-build",
+        help="Build a fixed-semantic spatial JSON manifest",
+    )
+    spatial_build_parser.add_argument("file", help="Path to the source file")
+    spatial_build_parser.add_argument(
+        "--lang", default=None,
+        help="Source language code (e.g., en, fr, hi). Auto-detect if omitted.",
+    )
+    spatial_build_parser.add_argument(
+        "--out", default="program.spatial.json",
+        help="Output JSON manifest path (default: program.spatial.json)",
+    )
+
+    polymodal_build_parser = subparsers.add_parser(
+        "polymodal-build",
+        help="Build a modality-free semantic core manifest",
+    )
+    polymodal_build_parser.add_argument("file", help="Path to the source file")
+    polymodal_build_parser.add_argument(
+        "--lang", default=None,
+        help="Source language code (e.g., en, fr, hi). Auto-detect if omitted.",
+    )
+    polymodal_build_parser.add_argument(
+        "--out", default="program.semantic.json",
+        help="Output JSON manifest path (default: program.semantic.json)",
+    )
+
+    process_build_parser = subparsers.add_parser(
+        "process-build",
+        help="Build a semantic-core-v1 process manifest (dynamics as data)",
+    )
+    process_build_parser.add_argument("file", help="Path to the source file")
+    process_build_parser.add_argument(
+        "--lang", default=None,
+        help="Source language code (e.g., en, fr, hi). Auto-detect if omitted.",
+    )
+    process_build_parser.add_argument(
+        "--out", default="program.v1.json",
+        help="Output JSON manifest path (default: program.v1.json)",
+    )
+
+    sonic_build_parser = subparsers.add_parser(
+        "sonic-build",
+        help="Build a sonic projection JSON manifest",
+    )
+    sonic_build_parser.add_argument("file", help="Path to the source file")
+    sonic_build_parser.add_argument(
+        "--lang", default=None,
+        help="Source language code (e.g., en, fr, hi). Auto-detect if omitted.",
+    )
+    sonic_build_parser.add_argument(
+        "--out", default="program.sonic.json",
+        help="Output JSON manifest path (default: program.sonic.json)",
+    )
+
+    ontology_export_parser = subparsers.add_parser(
+        "ontology-export",
+        help="Write the shared opcode ontology JSON (for browser runtimes)",
+    )
+    ontology_export_parser.add_argument(
+        "--out", default="ontology.json",
+        help="Output JSON path (default: ontology.json)",
+    )
+
+    linear_build_parser = subparsers.add_parser(
+        "linear-build",
+        help="Build a 1D linear timeline JSON manifest",
+    )
+    linear_build_parser.add_argument("file", help="Path to the source file")
+    linear_build_parser.add_argument(
+        "--lang", default=None,
+        help="Source language code (e.g., en, fr, hi). Auto-detect if omitted.",
+    )
+    linear_build_parser.add_argument(
+        "--out", default="program.linear.json",
+        help="Output JSON manifest path (default: program.linear.json)",
+    )
+
+    volumetric_build_parser = subparsers.add_parser(
+        "volumetric-build",
+        help="Build a 3D volumetric JSON manifest",
+    )
+    volumetric_build_parser.add_argument("file", help="Path to the source file")
+    volumetric_build_parser.add_argument(
+        "--lang", default=None,
+        help="Source language code (e.g., en, fr, hi). Auto-detect if omitted.",
+    )
+    volumetric_build_parser.add_argument(
+        "--out", default="program.volumetric.json",
+        help="Output JSON manifest path (default: program.volumetric.json)",
+    )
+
+    midi_build_parser = subparsers.add_parser(
+        "midi-build",
+        help="Build a MIDI event JSON manifest",
+    )
+    midi_build_parser.add_argument("file", help="Path to the source file")
+    midi_build_parser.add_argument(
+        "--lang", default=None,
+        help="Source language code (e.g., en, fr, hi). Auto-detect if omitted.",
+    )
+    midi_build_parser.add_argument(
+        "--out", default="program.midi.json",
+        help="Output JSON manifest path (default: program.midi.json)",
+    )
+
     # ir subcommand
     ir_parser = subparsers.add_parser(
         "ir", help="Show the semantic IR for a source file"
@@ -805,6 +1017,22 @@ def main():  # pylint: disable=too-many-statements
         cmd_build_wasm_bundle(args)
     elif args.command == "build-ui-bundle":
         cmd_build_ui_bundle(args)
+    elif args.command == "spatial-build":
+        cmd_spatial_build(args)
+    elif args.command == "polymodal-build":
+        cmd_polymodal_build(args)
+    elif args.command == "process-build":
+        cmd_process_build(args)
+    elif args.command == "sonic-build":
+        cmd_sonic_build(args)
+    elif args.command == "ontology-export":
+        cmd_ontology_export(args)
+    elif args.command == "linear-build":
+        cmd_linear_build(args)
+    elif args.command == "volumetric-build":
+        cmd_volumetric_build(args)
+    elif args.command == "midi-build":
+        cmd_midi_build(args)
     elif args.command == "ir":
         cmd_ir(args)
     elif args.command == "explain":

multilingualprogramming-0.8.0/multilingualprogramming/codegen/linear_manifest.py

@@ -0,0 +1,96 @@
+#
+# SPDX-FileCopyrightText: 2026 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Linear (1D timeline) projection of a polymodal program.
+
+Peer of the spatial (2D) and sonic projections. Takes the modality-free
+semantic core and produces a one-dimensional manifest: each entity
+becomes a positioned mark along a single axis. Phase determines the
+position; opcode determines the glyph and color.
+
+Adding 1D as a peer projection (rather than a parameterization of the
+2D spatial projection) is deliberate. The 1D rendering primitives
+(dot, segment, pulse, ramp, wave, fork, join, band, shift, double)
+do not generalize from 2D shapes -- "ring" and "membrane" have no
+natural 1D analog. Peer projections force the equivalence test to
+exercise the dimensionality axis rather than silently treating
+"spatial" as a monolith.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from multilingualprogramming.codegen import opcode_ontology
+from multilingualprogramming.codegen.projection_capabilities import capability_contract
+from multilingualprogramming.codegen.semantic_core import build_semantic_core
+
+MANIFEST_KIND = "linear-seed-v0"
+
+
+def build_linear_manifest(
+    source: str,
+    language: str = "en",
+    source_path: str = "",
+) -> dict[str, Any]:
+    """Execute Multilingual source and return a validated linear manifest."""
+    core = build_semantic_core(source, language=language, source_path=source_path)
+    marks = [_mark_from_semantic_entity(entity) for entity in core["entities"]]
+    return {
+        "kind": MANIFEST_KIND,
+        "version": 0,
+        "source_language": language,
+        "source": source_path,
+        "capabilities": capability_contract(
+            projection=MANIFEST_KIND,
+            preserves=["id", "opcode", "intensity", "phase", "channel"],
+            derived=[],
+            lossy=["signal"],
+            ambiguous=[],
+            inverse="view-only",
+        ),
+        "tempo_bpm": 96,
+        "bar_seconds": 4.0,
+        "marks": marks,
+    }
+
+
+def build_linear_manifest_file(
+    source_path: str | Path,
+    output_path: str | Path,
+    language: str = "en",
+) -> dict[str, Any]:
+    """Build and write a linear manifest from a Multilingual source file."""
+    src = Path(source_path)
+    out = Path(output_path)
+    manifest = build_linear_manifest(
+        src.read_text(encoding="utf-8"),
+        language=language,
+        source_path=str(src),
+    )
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    return manifest
+
+
+def _mark_from_semantic_entity(entity: dict[str, Any]) -> dict[str, Any]:
+    op = opcode_ontology.get(entity["opcode"])
+    return {
+        "id": entity["id"],
+        "index": int(entity["index"]),
+        "opcode": op.code,
+        "name": op.name,
+        "glyph": op.linear.glyph,
+        "color": op.linear.color,
+        "position": round(float(entity["phase"]) % 1.0, 4),
+        "intensity": round(float(entity["intensity"]), 4),
+        "channel": int(entity["channel"]),
+    }

multilingualprogramming-0.8.0/multilingualprogramming/codegen/midi_capture.py

@@ -0,0 +1,156 @@
+#
+# SPDX-FileCopyrightText: 2026 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Inverse MIDI projection: observed MIDI events -> semantic core.
+
+The forward MIDI projection emits identity labels for manifests, but a
+real MIDI input stream does not carry ``opcode`` or ``name``. This
+module recovers semantic identity from the observable MIDI fields the
+ontology owns: role and pitch.
+
+MIDI capture is deliberately partial:
+
+- ``bus`` events are silent routing markers, not recoverable input.
+- ``program`` events in the current ontology have base velocity 0, so
+  intensity cannot be recovered.
+- events whose velocity has clipped to 127 cannot recover the original
+  intensity exactly.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+from multilingualprogramming.codegen import opcode_ontology
+from multilingualprogramming.codegen.semantic_core import CORE_KIND
+
+
+@dataclass(frozen=True)
+class ObservedMidiEvent:
+    """A MIDI event as it would arrive from a MIDI input boundary."""
+
+    index: int
+    role: str
+    pitch: int
+    velocity: int
+    channel: int
+    start_offset: float
+
+
+def _ontology_signature(op: opcode_ontology.Opcode) -> tuple[str, int]:
+    return (op.midi.role, op.midi.pitch)
+
+
+def invertible_opcodes() -> set[int]:
+    """Opcodes whose identity can be recovered from MIDI observation."""
+    signature_counts: dict[tuple[str, int], int] = {}
+    for op in opcode_ontology.OPCODES:
+        signature = _ontology_signature(op)
+        signature_counts[signature] = signature_counts.get(signature, 0) + 1
+    return {
+        op.code
+        for op in opcode_ontology.OPCODES
+        if op.midi.role != "bus"
+        and op.midi.velocity > 0
+        and signature_counts[_ontology_signature(op)] == 1
+    }
+
+
+def observe_event(event: dict[str, Any]) -> ObservedMidiEvent:
+    """Strip semantic identity labels from a forward-projected MIDI event."""
+    return ObservedMidiEvent(
+        index=int(event["index"]),
+        role=str(event["role"]),
+        pitch=int(event["pitch"]),
+        velocity=int(event["velocity"]),
+        channel=int(event["channel"]),
+        start_offset=float(event["start_offset"]),
+    )
+
+
+def _opcode_from_observation(
+    observed: ObservedMidiEvent,
+) -> opcode_ontology.Opcode:
+    signature = (observed.role, observed.pitch)
+    matches = [
+        op for op in opcode_ontology.OPCODES if _ontology_signature(op) == signature
+    ]
+    if not matches:
+        raise ValueError(
+            f"No ontology opcode matches MIDI observation {signature!r} "
+            f"on event index {observed.index}"
+        )
+    if len(matches) > 1:
+        names = ", ".join(op.name for op in matches)
+        raise ValueError(
+            f"MIDI observation {signature!r} on event index {observed.index} is "
+            f"ambiguous: matches {names}."
+        )
+    op = matches[0]
+    if op.midi.role == "bus":
+        raise ValueError(
+            f"MIDI event index {observed.index} resolves to bus opcode {op.name!r}; "
+            "silent routing events are not recoverable authoring input."
+        )
+    if op.midi.velocity <= 0:
+        raise ValueError(
+            f"MIDI event index {observed.index} resolves to opcode {op.name!r} "
+            "with zero base velocity; intensity cannot be recovered."
+        )
+    return op
+
+
+def _intensity_from_velocity(
+    op: opcode_ontology.Opcode,
+    observed: ObservedMidiEvent,
+) -> float:
+    if not 0 <= observed.velocity <= 127:
+        raise ValueError(
+            f"MIDI event index {observed.index} velocity must be in 0..127"
+        )
+    if observed.velocity == 127:
+        raise ValueError(
+            f"MIDI event index {observed.index} is clipped at velocity 127; "
+            "original intensity is lossy."
+        )
+    return observed.velocity / op.midi.velocity
+
+
+def capture_semantic_core(
+    observed: Iterable[ObservedMidiEvent],
+    *,
+    source_language: str = "en",
+    source_path: str = "",
+) -> dict[str, Any]:
+    """Invert observed MIDI events into a semantic-core manifest."""
+    entities: list[dict[str, Any]] = []
+    for event in observed:
+        op = _opcode_from_observation(event)
+        intensity = _intensity_from_velocity(op, event)
+        entities.append(
+            {
+                "index": event.index,
+                "opcode": op.code,
+                "name": op.name,
+                "intensity": intensity,
+                "signal": 0.0,
+                "phase": event.start_offset,
+                "channel": event.channel,
+            }
+        )
+    return {
+        "kind": CORE_KIND,
+        "version": 0,
+        "source_language": source_language,
+        "source": source_path,
+        "ontology": [
+            {"code": op.code, "name": op.name}
+            for op in opcode_ontology.OPCODES
+        ],
+        "entities": entities,
+        "relations": [],
+    }

multilingualprogramming-0.8.0/multilingualprogramming/codegen/midi_manifest.py

@@ -0,0 +1,110 @@
+#
+# SPDX-FileCopyrightText: 2026 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""MIDI projection of a polymodal program.
+
+Peer of the linear / spatial / volumetric / sonic projections. Where
+those projections describe continuous shapes (along 1/2/3 spatial axes
+or in audio), MIDI describes the program as a sequence of discrete
+events: note on/off, control change, program change, percussion hits.
+
+This is the modality that stress-tests whether the ontology is
+genuinely modality-free. If our opcode primitives only mapped cleanly
+to continuous-shape projections, MIDI would be where that cracked --
+because MIDI's contract is fundamentally event-flavored rather than
+field-flavored. Each opcode commits to a MIDI role
+(``note``, ``drum``, ``cc``, ``program``, ``bus``) via its
+:class:`MidiHint`, and the projection here turns the semantic core
+into a flat list of MIDI events ready for a piano-roll renderer or
+Web MIDI output.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from multilingualprogramming.codegen import opcode_ontology
+from multilingualprogramming.codegen.projection_capabilities import capability_contract
+from multilingualprogramming.codegen.semantic_core import build_semantic_core
+
+MANIFEST_KIND = "midi-seed-v0"
+
+
+def build_midi_manifest(
+    source: str,
+    language: str = "en",
+    source_path: str = "",
+) -> dict[str, Any]:
+    """Execute Multilingual source and return a validated MIDI manifest."""
+    core = build_semantic_core(source, language=language, source_path=source_path)
+    events = [_event_from_semantic_entity(entity) for entity in core["entities"]]
+    return {
+        "kind": MANIFEST_KIND,
+        "version": 0,
+        "source_language": language,
+        "source": source_path,
+        "capabilities": capability_contract(
+            projection=MANIFEST_KIND,
+            preserves=["id", "opcode", "phase", "channel"],
+            derived=["intensity"],
+            lossy=["signal", "intensity when velocity clips or base velocity is zero"],
+            ambiguous=[],
+            inverse="partial",
+        ),
+        "tempo_bpm": 96,
+        "bar_seconds": 4.0,
+        "events": events,
+        "relations": core["relations"],
+    }
+
+
+def build_midi_manifest_file(
+    source_path: str | Path,
+    output_path: str | Path,
+    language: str = "en",
+) -> dict[str, Any]:
+    """Build and write a MIDI manifest from a Multilingual source file."""
+    src = Path(source_path)
+    out = Path(output_path)
+    manifest = build_midi_manifest(
+        src.read_text(encoding="utf-8"),
+        language=language,
+        source_path=str(src),
+    )
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    return manifest
+
+
+def _event_from_semantic_entity(entity: dict[str, Any]) -> dict[str, Any]:
+    op = opcode_ontology.get(entity["opcode"])
+    intensity = float(entity["intensity"])
+
+    # Bus voices are silent under the forward MIDI projection just as
+    # they are silent under sonic. The event is still emitted so peer
+    # projections agree on entity count and ordering -- runtimes simply
+    # do not transmit it.
+    if op.midi.role == "bus":
+        velocity = 0
+    else:
+        velocity = max(0, min(127, round(op.midi.velocity * intensity)))
+
+    return {
+        "id": entity["id"],
+        "index": int(entity["index"]),
+        "opcode": op.code,
+        "name": op.name,
+        "role": op.midi.role,
+        "pitch": op.midi.pitch,
+        "velocity": velocity,
+        "channel": int(entity["channel"]),
+        "start_offset": round(float(entity["phase"]) % 1.0, 4),
+    }