**Developing an interactive script** I need to create a response for the user asking about a Rich Python script that converts BIAB SG1, SG4, MGU, MG1, MGF, or KAR into full MIDI. I must be careful about BIAB's proprietary binary styles that generic converters might not handle well. I can't invent a package or unsupported parser, and there are no external tools available. I have a working script for KAR and want to explore open-source options too, like the MMA BIAB parser. I’ll evaluate current knowledge on open-source Python packages before moving forward.**Crafting an interactive Python script** I need to avoid hallucinating an exact parser. One option is creating a robust interactive Python wrapper for abcmidi's midi2abc tool. I’m considering using BIAB to convert to MusicXML with the music21 library, which can handle several formats like Capella and ABC. However, it doesn't currently support BIAB. The MMA tool can import .mgu files and I'd like to recall its documentation. I have enough time and budget to produce a correct solution while respecting the user's request and being honest about limitations. Let's explore the open-source options for an interactive Rich script! There is an important distinction: - **KAR files are normally already Standard MIDI Files.** Changing the extension after validation preserves all tracks, instruments, controllers, and lyrics. - **BIAB files generally contain song instructions, not a complete rendered performance.** Producing MIDI requires generating accompaniment. An open-source solution cannot promise to reproduce BIAB’s proprietary styles or RealTracks exactly. The script below provides an **automatic, cross-platform, best-effort solution**: | Input | Processing | |---|---| | KAR | Validate and copy losslessly to `.mid` | | BIAB | Import through MuseScore 3 → read MusicXML → generate piano, bass, strings, and drums, plus any imported melody notes | **BIAB limitations:** MuseScore’s legacy importer does not support every BIAB revision and may import chords without the melody. Consequently, this produces a **new multitrack arrangement**, not a guaranteed reconstruction of every original BIAB track. Files without usable imported chords are rejected rather than “converted” into misleading output. ## Installation Use Python 3.11 or newer: ```bash python -m pip install rich mido music21 ``` For BIAB conversion, also install **MuseScore 3**, preferably [MuseScore 3.6.2](https://github.com/musescore/MuseScore/releases/tag/v3.6.2). This implementation specifically targets its legacy BIAB importer; it does not assume MuseScore 4 has equivalent support. All these components are free/open-source. No Wine, commercial software, or SoundFont is required to create the MIDI files. Save the following as `biab_kar_to_midi.py`. ```python #!/usr/bin/env python3 # SPDX-License-Identifier: MIT from __future__ import annotations import io import os import re import shutil import subprocess import tempfile from bisect import bisect_right from dataclasses import dataclass from pathlib import Path import mido import music21 as m21 from rich.console import Console from rich.markup import escape from rich.panel import Panel from rich.prompt import Confirm, IntPrompt, Prompt from rich.table import Table from rich.text import Text console = Console() PPQ = 960 PIANO_CHANNEL = 12 BASS_CHANNEL = 13 STRINGS_CHANNEL = 14 DRUM_CHANNEL = 9 # MIDI channel 10, using zero-based numbering # Includes SG1, SG4, SGU, MG1, MGU, MGF, MGX, etc. # Matching an extension does NOT guarantee that its BIAB revision is importable. BIAB_EXTENSION = re.compile(r"\.[ms]g[a-z0-9]", re.IGNORECASE) def as_path(value: str) -> Path: return Path(value.strip().strip('"').strip("'")).expanduser() def is_biab(path: Path) -> bool: return BIAB_EXTENSION.fullmatch(path.suffix) is not None def supported(path: Path) -> bool: return path.suffix.lower() == ".kar" or is_biab(path) def ticks(quarter_length) -> int: return round(float(quarter_length) * PPQ) def atomic_write(target: Path, data: bytes) -> None: """Write in the destination directory, then atomically replace the target.""" target.parent.mkdir(parents=True, exist_ok=True) fd, temporary = tempfile.mkstemp( prefix=".midi-", suffix=".tmp", dir=str(target.parent) ) try: with os.fdopen(fd, "wb") as handle: handle.write(data) os.replace(temporary, target) finally: Path(temporary).unlink(missing_ok=True) def convert_kar(source: Path) -> bytes: data = source.read_bytes() if not data.startswith(b"MThd"): raise ValueError( "This KAR is not a Standard MIDI File: missing MThd header. " "Non-standard karaoke containers are not supported." ) # Validate, but do not reserialize: preserve the original bytes and events. mido.MidiFile(file=io.BytesIO(data)) return data def choose_musescore() -> str: guess = os.environ.get("MUSESCORE3", "") if not guess: for name in ("MuseScore3", "musescore3", "mscore3", "mscore", "musescore"): found = shutil.which(name) if found: guess = found break raw = Prompt.ask( "MuseScore 3 executable path, command name, or macOS .app", default=guess, ).strip().strip('"').strip("'") if not raw: raise ValueError("A MuseScore 3 executable is required for BIAB files.") found = shutil.which(raw) executable = Path(found) if found else as_path(raw) if executable.is_dir() and executable.suffix.lower() == ".app": executable = executable / "Contents" / "MacOS" / "mscore" executable = executable.resolve() if not executable.is_file(): raise FileNotFoundError(f"Executable not found: {executable}") result = subprocess.run( [str(executable), "--version"], capture_output=True, text=True, errors="replace", timeout=30, check=False, ) version = result.stdout + "\n" + result.stderr if result.returncode != 0 or not re.search(r"\b3\.\d", version): raise RuntimeError( "This script requires MuseScore 3.x, preferably 3.6.2.\n" + version.strip()[-1000:] ) return str(executable) def import_biab(source: Path, executable: str): with tempfile.TemporaryDirectory(prefix="biab-import-") as directory: work = Path(directory) # Normalize the suffix only to select MuseScore's BIAB importer. # This does NOT make an unsupported binary format supported. suffix = ".mgu" if source.suffix.lower().startswith(".mg") else ".sgu" staged = work / ("input" + suffix) musicxml = work / "imported.musicxml" shutil.copyfile(source, staged) result = subprocess.run( [executable, "-o", str(musicxml), str(staged)], capture_output=True, text=True, errors="replace", timeout=180, check=False, ) if ( result.returncode != 0 or not musicxml.is_file() or musicxml.stat().st_size == 0 ): log = (result.stdout + "\n" + result.stderr).strip() raise RuntimeError( "MuseScore could not import this BIAB file.\n" + log[-1500:] ) score = m21.converter.parse(str(musicxml), forceSource=True) if not isinstance(score, m21.stream.Score): raise ValueError("The importer did not produce a usable score.") # Do not silently discard repeat-processing failures. try: score = score.expandRepeats() score = score.stripTies(inPlace=False) except Exception as exc: raise ValueError( f"Could not resolve the imported repeats/ties: {exc}" ) from exc return score @dataclass(frozen=True) class HarmonySpan: start: int end: int tones: tuple[int, ...] bass: int fifth: int def read_harmonies(score, total: int) -> list[HarmonySpan]: changes = {} for symbol in score.recurse().getElementsByClass(m21.harmony.ChordSymbol): position = max(0, ticks(symbol.getOffsetInHierarchy(score))) if position >= total: continue if ( isinstance(symbol, m21.harmony.NoChord) or symbol.chordKind == "none" ): specification = ((), 0, 0) else: root = symbol.root() bass = symbol.bass() pitches = symbol.pitches if root is None or bass is None or not pitches: raise ValueError( f"Cannot interpret imported chord: {symbol.figure!r}" ) fifth = symbol.getChordStep(5) if fifth is None: fifth = root # Deliberately simple, close-position GM voicings. tones = tuple(sorted({60 + int(p.pitchClass) for p in pitches})) specification = ( tones, 36 + int(bass.pitchClass), 36 + int(fifth.pitchClass), ) if position in changes and changes[position] != specification: raise ValueError( "Conflicting chord symbols at quarter-note offset " f"{position / PPQ:g}." ) changes[position] = specification if not changes or not any(spec[0] for spec in changes.values()): raise ValueError( "No usable chord symbols were imported. " "Cannot generate a full backing arrangement." ) positions = sorted(changes) spans = [] for index, start in enumerate(positions): end = positions[index + 1] if index + 1 < len(positions) else total spans.append(HarmonySpan(start, end, *changes[start])) return spans def add_note(events, channel, pitch, start, end, velocity): if end <= start: return events.append( ( start, 2, mido.Message( "note_on", channel=channel, note=int(pitch), velocity=int(velocity), ), ) ) events.append( ( end, 0, # Note-offs precede simultaneous note-ons. mido.Message( "note_off", channel=channel, note=int(pitch), velocity=0 ), ) ) def make_track(name, events, total, channel=None, program=0): track = mido.MidiTrack() track.append(mido.MetaMessage("track_name", name=name, time=0)) if channel is not None: track.append( mido.Message( "control_change", channel=channel, control=0, value=0, time=0 ) ) track.append( mido.Message( "control_change", channel=channel, control=32, value=0, time=0 ) ) track.append( mido.Message( "program_change", channel=channel, program=int(program), time=0, ) ) previous = 0 for position, priority, message in sorted( events, key=lambda item: (item[0], item[1]) ): track.append(message.copy(time=position - previous)) previous = position track.append( mido.MetaMessage("end_of_track", time=max(0, total - previous)) ) return track def render_biab(source, executable, groove, tempo_override): score = import_biab(source, executable) parts = list(score.parts) total = ticks(score.highestTime) if not parts or total <= 0: raise ValueError("The imported score is empty.") measures = list(parts[0].getElementsByClass(m21.stream.Measure)) if not measures: raise ValueError("The imported score has no usable measures.") spans = read_harmonies(score, total) starts = [span.start for span in spans] def harmony_at(position): index = bisect_right(starts, position) - 1 if index >= 0: span = spans[index] if position < span.end and span.tones: return span return None midi = mido.MidiFile(type=1, ticks_per_beat=PPQ, charset="utf-8") # Conductor track: imported tempo/meter, or an explicit tempo override. tempo_points = {0: tempo_override or 120} if not tempo_override: for mark in score.recurse().getElementsByClass(m21.tempo.MetronomeMark): bpm = mark.getQuarterBPM() position = max(0, ticks(mark.getOffsetInHierarchy(score))) if bpm is not None and bpm > 0 and position < total: tempo_points[position] = float(bpm) meter_points = {0: (4, 4)} for signature in score.recurse().getElementsByClass( m21.meter.TimeSignature ): position = max(0, ticks(signature.getOffsetInHierarchy(score))) if position < total: meter_points[position] = ( signature.numerator, signature.denominator, ) conductor = [ ( 0, 1, mido.MetaMessage( "text", text="New GM accompaniment; not original BIAB styles", ), ) ] for position, bpm in tempo_points.items(): conductor.append( (position, 1, mido.MetaMessage("set_tempo", tempo=mido.bpm2tempo(bpm))) ) for position, (numerator, denominator) in meter_points.items(): conductor.append( ( position, 1, mido.MetaMessage( "time_signature", numerator=numerator, denominator=denominator, ), ) ) midi.tracks.append(make_track("Conductor", conductor, total)) # Preserve pitched notes exposed by the importer. # This is not a reconstruction of BIAB's original performance expression. free_channels = [ channel for channel in range(16) if channel not in { PIANO_CHANNEL, BASS_CHANNEL, STRINGS_CHANNEL, DRUM_CHANNEL } ] imported_notes = 0 for part in parts: part_offset = part.getOffsetInHierarchy(score) notes = [ item for item in part.flatten().notes if not isinstance(item, m21.harmony.Harmony) and item.duration.quarterLength > 0 ] if not notes: continue if not free_channels: raise ValueError("Too many imported parts for the available MIDI channels.") channel = free_channels.pop(0) events = [] for item in notes: if isinstance(item, m21.note.Unpitched): raise ValueError( "An imported unpitched part needs explicit percussion mapping." ) pitches = ( (item.pitch,) if isinstance(item, m21.note.Note) else item.pitches ) start = max(0, ticks(part_offset + item.offset)) end = min( total, ticks(part_offset + item.offset + item.duration.quarterLength), ) velocity = item.volume.velocity velocity = 90 if velocity is None else int(velocity) if velocity <= 0 or end <= start: continue velocity = min(127, velocity) for pitch in pitches: add_note(events, channel, pitch.midi, start, end, velocity) imported_notes += 1 instrument = part.getInstrument(returnDefault=True) midi.tracks.append( make_track( part.partName or "Imported notes", events, total, channel, instrument.midiProgram or 0, ) ) piano_events, bass_events, strings_events, drum_events = [], [], [], [] # hit -> (nominal beat length, alternate-bass flag) hits = {} measure_starts = [ max(0, ticks(measure.getOffsetInHierarchy(score))) for measure in measures ] current_meter = m21.meter.TimeSignature("4/4") for index, measure in enumerate(measures): current_meter = measure.timeSignature or current_meter start = measure_starts[index] end = ( min(total, measure_starts[index + 1]) if index + 1 < len(measures) else total ) compound = ( current_meter.denominator >= 8 and current_meter.numerator > 3 and current_meter.numerator % 3 == 0 ) beat_length = max( 1, round( PPQ * 4 / current_meter.denominator * (3 if compound else 1) ), ) if compound: subdivisions = (0, 1 / 3, 2 / 3) else: subdivisions = (0, 2 / 3 if groove == "swing" else 1 / 2) for beat_index, position in enumerate(range(start, end, beat_length)): hits[position] = (beat_length, beat_index % 2) # Simple kick/snare groove, not a proprietary BIAB style. drum_note = 36 if beat_index % 2 == 0 else 38 add_note( drum_events, DRUM_CHANNEL, drum_note, position, min(end, position + PPQ // 12), 82, ) for subdivision_index, fraction in enumerate(subdivisions): hat_position = position + round(beat_length * fraction) if hat_position >= end: continue add_note( drum_events, DRUM_CHANNEL, 51 if groove == "swing" else 42, hat_position, min(end, hat_position + PPQ // 12), 52 if subdivision_index == 0 else 40, ) # Also articulate off-beat chord changes; N.C. silences pitched backing. for span in spans: if not span.tones: continue beat_length = hits.get(span.start, (PPQ, 0))[0] hits[span.start] = (beat_length, 0) for pitch in span.tones: add_note( strings_events, STRINGS_CHANNEL, pitch - 12, span.start, span.end, 42, ) positions = sorted(hits) for index, position in enumerate(positions): span = harmony_at(position) if span is None: continue beat_length, alternate = hits[position] next_hit = positions[index + 1] if index + 1 < len(positions) else total limit = min(span.end, next_hit) piano_end = min(limit, position + round(beat_length * 0.60)) bass_end = min(limit, position + round(beat_length * 0.90)) for pitch in span.tones: add_note( piano_events, PIANO_CHANNEL, pitch, position, piano_end, 66, ) add_note( bass_events, BASS_CHANNEL, span.fifth if alternate else span.bass, position, bass_end, 82, ) # General MIDI program numbers are zero-based here. for name, events, channel, program in ( ("Generated piano", piano_events, PIANO_CHANNEL, 0), ("Generated acoustic bass", bass_events, BASS_CHANNEL, 32), ("Generated strings", strings_events, STRINGS_CHANNEL, 48), ("Generated drums", drum_events, DRUM_CHANNEL, 0), ): midi.tracks.append(make_track(name, events, total, channel, program)) buffer = io.BytesIO() midi.save(file=buffer) return buffer.getvalue(), imported_notes def main() -> int: console.print( Panel( "KAR → lossless Standard MIDI copy\n" "BIAB → newly generated GM accompaniment + imported notes\n\n" "BIAB compatibility and melody availability depend on MuseScore 3.\n" "Original BIAB styles/RealTracks are not reproduced. Ctrl+C cancels.", title="BIAB / KAR → MIDI", ) ) source = as_path(Prompt.ask("Input file or folder")).resolve() if source.is_dir(): root = source recursive = Confirm.ask("Search subfolders?", default=True) candidates = source.rglob("*") if recursive else source.iterdir() files = sorted( (path for path in candidates if path.is_file() and supported(path)), key=lambda path: str(path).casefold(), ) elif source.is_file() and supported(source): root = source.parent files = [source] else: raise ValueError("Choose a KAR file, a BIAB song file, or a folder.") if not files: raise ValueError("No supported filename extensions were found.") console.print(f"Found [bold]{len(files)}[/bold] input file(s).") output = as_path( Prompt.ask("Output folder", default=str(root / "midi_output")) ).resolve() executable = None groove = "straight" tempo_override = 0 if any(is_biab(path) for path in files): executable = choose_musescore() groove = Prompt.ask( "BIAB backing subdivision", choices=["straight", "swing"], default="straight", ) while True: tempo_override = IntPrompt.ask( "BIAB tempo: 0 = imported tempo, falling back to 120 BPM", default=0, ) if tempo_override == 0 or 20 <= tempo_override <= 400: break console.print("[yellow]Enter 0, or a BPM from 20 to 400.[/yellow]") overwrite = Confirm.ask("Overwrite existing output files?", default=False) if not Confirm.ask("Start conversion?", default=True): return 0 results = Table(title="Conversion results") results.add_column("Input", overflow="fold") results.add_column("Status") results.add_column("Details", overflow="fold") failures = 0 for path in files: relative = path.relative_to(root) # Keep the input suffix to distinguish song.MGU from song.SGU, etc. target = output / relative.parent / (relative.name + ".mid") if target.exists() and not overwrite: results.add_row(Text(str(relative)), "SKIP", "Output already exists") continue try: if target.resolve() == path.resolve(): raise ValueError("Refusing to overwrite an input file.") warning = False with console.status(f"Converting {escape(str(relative))}"): if path.suffix.lower() == ".kar": data = convert_kar(path) detail = "Original MIDI events retained byte-for-byte" else: data, imported = render_biab( path, executable, groove, tempo_override ) detail = f"New backing + {imported} imported note-ons" if path.suffix.lower().startswith(".mg") and imported == 0: warning = True detail += "; no BIAB melody was imported" atomic_write(target, data) results.add_row( Text(str(relative)), Text("WARN" if warning else "OK", style="yellow" if warning else "green"), Text(detail), ) except Exception as exc: failures += 1 results.add_row( Text(str(relative)), Text("ERROR", style="red"), Text(str(exc)), ) console.print(results) console.print("Output folder:", Text(str(output))) console.print( "[dim]Output names retain the source suffix, e.g. Song.MGU.mid. " "Input files are never modified.[/dim]" ) return 1 if failures else 0 if __name__ == "__main__": try: raise SystemExit(main()) except KeyboardInterrupt: console.print("\n[yellow]Cancelled.[/yellow]") raise SystemExit(130) except Exception as exc: console.print(Text(f"Error: {exc}", style="red")) raise SystemExit(1) ``` Run it with: ```bash python biab_kar_to_midi.py ``` ### What to expect - **KAR:** the resulting `.mid` contains exactly the original MIDI data, including karaoke lyrics. - **BIAB:** a Type-1 MIDI containing generated accompaniment and any pitched notes exposed by the importer. - **Unrecognized BIAB versions:** an error for that file; other batch entries continue. - **Missing BIAB melody:** explicitly reported for `.MG*` inputs. The generated backing is intentionally basic. For more sophisticated open-source accompaniment, **JJazzLab** is worth considering as a GUI-based alternative—but neither approach should be described as guaranteed recovery of the original BIAB performance.

Create an interactive (with Rich) Python script for turning ...