st-language 2.7.0__py3-none-any.whl

st_language/__init__.py

@@ -0,0 +1,87 @@
+"""
+ST-language: la notazione musicale testuale di SoundText come libreria
+Python autonoma (nessuna dipendenza esterna, Python 3.8+).
+
+    import st_language as st
+
+    events = st.parse("4: c d e f | 2g 2g")          # eventi con tempi in quarti
+    ok, error = st.validate("4: C Am | F G")
+    warnings = st.check("4: c d e | f")               # controlli di battuta, testo cantato
+
+    song = st.load_song("brano.st")                    # o st.read_song(testo)
+    st.to_midi(song, "brano.mid")
+    st.to_musicxml(song, "brano.musicxml")
+    st.to_abc(song, "brano.abc")
+    st.to_mtxt(song, "brano.mtxt")                    # MTXT 1.0, un evento per riga
+    st.mtxt_to_midi(open("take.mtxt").read(), "take.mid")
+
+La specifica del linguaggio e del formato .st e' in docs/spec/ del
+repository di SoundText; i comandi da terminale sono 'st-language'
+(check, midi, musicxml, abc, mtxt, events), 'stcheck', 'st2mid', 'st2musicxml',
+'st2abc', 'st2mtxt'.
+"""
+
+from typing import Dict, List, Optional, Tuple
+
+from ._i18n import language, set_language, set_translator  # noqa: F401
+from .notation import (  # noqa: F401
+    BarIssue, Event, Meter, NotationError, Pattern, check_bar_lines, notation_warnings, parse_track_text,
+    tokenize, transpose_tokens, validate_track_text,
+)
+from .song import Clip, Part, Song, load_song, read_song, song_from_notation, text_to_song  # noqa: F401
+
+__version__ = "2.7.0"
+
+__all__ = [
+    "BarIssue", "Clip", "Event", "Meter", "NotationError", "Part", "Pattern", "Song", "check", "check_bar_lines",
+    "language", "load_song", "notation_warnings", "parse", "parse_track_text", "read_song",
+    "mtxt_to_midi", "set_language", "set_translator", "song_from_notation", "text_to_song", "to_abc",
+    "to_midi", "to_musicxml", "to_mtxt", "tokenize", "transpose_tokens", "validate", "validate_track_text",
+]
+
+
+def parse(text: str, patterns: Optional[Dict[str, Pattern]] = None, default_octave: int = 4) -> List[Event]:
+    """Gli eventi di un testo in notazione (una traccia)."""
+    return parse_track_text(text, patterns or {}, default_octave=default_octave)
+
+
+def validate(text: str, patterns: Optional[Dict[str, Pattern]] = None) -> Tuple[bool, str]:
+    """(True, '') se il testo e' valido, altrimenti (False, messaggio)."""
+    return validate_track_text(text, patterns or {})
+
+
+def check(text: str, patterns: Optional[Dict[str, Pattern]] = None, time_sig: str = "4/4",
+          metrica_changes=(), pickup=0) -> List[BarIssue]:
+    """Gli avvisi che non impediscono di suonare: controlli di battuta e
+    testo cantato con troppe sillabe. 'pickup': quarti del levare."""
+    return notation_warnings(text, patterns or {}, time_sig, metrica_changes, pickup=pickup)
+
+
+def to_midi(song: Song, path: str, only_audible: bool = True) -> str:
+    from .midi import song_to_midi
+    return song_to_midi(song, path, only_audible=only_audible)
+
+
+def to_musicxml(song: Song, path: str, only_audible: bool = True) -> str:
+    from .musicxml import export_project_to_musicxml
+    return export_project_to_musicxml(song, path, only_audible=only_audible)
+
+
+def to_abc(song: Song, path: str, only_audible: bool = True) -> str:
+    from .abc import export_project_to_abc
+    return export_project_to_abc(song, path, only_audible=only_audible)
+
+
+def to_mtxt(song: Song, path: str, only_audible: bool = True) -> str:
+    """Il brano come file MTXT 1.0 (vedi st_language.mtxt); ritorna path."""
+    from .mtxt import song_to_mtxt
+    with open(path, "w", encoding="utf-8", newline="\n") as f:
+        f.write(song_to_mtxt(song, only_audible=only_audible))
+    return path
+
+
+def mtxt_to_midi(text: str, path: str) -> str:
+    """Un testo MTXT come file MIDI; ritorna path. Solleva
+    st_language.mtxt.MtxtError (un ValueError) se il testo non e' valido."""
+    from .mtxt import mtxt_to_midi as convert
+    return convert(text, path)

st_language/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

st_language/_i18n.py

@@ -0,0 +1,77 @@
+"""
+Messaggi della libreria (errori di sintassi, avvisi) nella lingua scelta.
+
+I testi sono scritti in italiano nel codice, dentro tr(), come in
+SoundText; i cataloghi locales/<lingua>.json ({testo italiano:
+traduzione}) danno l'inglese, il francese e lo spagnolo. La lingua si
+sceglie con set_language() o con la variabile d'ambiente ST_LANGUAGE
+(altrimenti LANG); senza indicazioni, l'inglese.
+
+Un programma che ha gia' le sue traduzioni (SoundText) puo' sostituire
+tr con set_translator(): tutti i messaggi passano allora da li'.
+"""
+
+import json
+import os
+from typing import Callable, Dict, Optional
+
+LANGUAGES = ("it", "en", "fr", "es")
+SOURCE_LANGUAGE = "it"
+DEFAULT_LANGUAGE = "en"
+
+_translator: Optional[Callable] = None
+_language: Optional[str] = None
+_catalog: Dict[str, str] = {}
+
+
+def set_translator(fn: Optional[Callable]) -> None:
+    """fn(testo_italiano, *args, **kwargs) -> testo; None torna ai cataloghi."""
+    global _translator
+    _translator = fn
+
+
+def _env_language() -> str:
+    for var in ("ST_LANGUAGE", "LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG"):
+        for part in os.environ.get(var, "").split(":"):
+            code = part.strip().lower()[:2]
+            if code in LANGUAGES:
+                return code
+    return DEFAULT_LANGUAGE
+
+
+def set_language(code: Optional[str] = None) -> str:
+    """Sceglie la lingua dei messaggi (None: dall'ambiente); ritorna quella in uso."""
+    global _language, _catalog
+    code = (code or _env_language()).lower()[:2]
+    if code not in LANGUAGES:
+        code = DEFAULT_LANGUAGE
+    _language = code
+    _catalog = {}
+    if code != SOURCE_LANGUAGE:
+        path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "locales", f"{code}.json")
+        try:
+            with open(path, encoding="utf-8") as f:
+                _catalog = {k: v for k, v in json.load(f).items() if isinstance(v, str) and v}
+        except (OSError, ValueError):
+            _catalog = {}
+    return code
+
+
+def language() -> str:
+    if _language is None:
+        set_language()
+    return _language
+
+
+def tr(text: str, *args, **kwargs) -> str:
+    if _translator is not None:
+        return _translator(text, *args, **kwargs)
+    if _language is None:
+        set_language()
+    out = _catalog.get(text, text)
+    if args or kwargs:
+        try:
+            return out.format(*args, **kwargs)
+        except (IndexError, KeyError, ValueError):
+            return text.format(*args, **kwargs)
+    return out

st_language/abc.py

@@ -0,0 +1,370 @@
+"""
+Esportazione del progetto in notazione ABC (standard 2.1), il formato di
+testo per partiture usato da abcjs, EasyABC, abcm2ps, abc2midi e dalle
+grandi raccolte di musica tradizionale.
+
+Lavora sugli stessi attacchi dell'esportazione MusicXML (st_language.
+musicxml): note, accordi gia' risolti dal motore di voicing, blocchi,
+percussioni, battute, tuplet, legature fra battute. Ogni pentagramma di
+ogni traccia diventa una voce ABC (V:), e le voci dei blocchi { ; } voci
+in piu' sullo stesso pentagramma, raggruppate con %%score: pianoforti e
+organi hanno due pentagrammi uniti da una graffa. Lo strumento passa con
+%%MIDI program (la batteria sul canale 10, con le note dei suoni GM), la
+tonalita' con K:, la metrica con M: e i cambi [M:] in tutte le voci, il
+tempo con Q: e [Q:], le sigle degli accordi fra virgolette, le dinamiche
+come decorazioni (!mf!), il testo cantato con w:. Il pedale del sustain
+non c'e' (non e' nello standard).
+Chitarre e bassi usano la chiave all'ottava bassa (treble-8, bass-8),
+con le note scritte un'ottava sopra come vuole lo standard.
+"""
+
+import dataclasses
+from fractions import Fraction
+from typing import Dict, List, Optional, Tuple, TYPE_CHECKING
+
+from .instruments import PERCUSSION_MAP
+from .musicxml import (QUANT_GRID, _Direction, _Entry, _Item, _clefs, _drop_repeated_harmonies,
+                       _dynamic_changes, _frac, _grid_divisions, _mark_lyrics, _measures, _monophonic,
+                       _repeat_layout, _spell_midi, _staff_entries, _track_harmonies, _track_items,
+                       _track_navigation, _track_repeats, _track_texts, _item_syllables, key_fifths,
+                       song_key_changes, NAVIGATION_WORDS)
+
+if TYPE_CHECKING:          # solo per le annotazioni (nessun import circolare)
+    from .song import Part, Song  # noqa: F401
+
+# Unita' di nota (L:) in quarti: l'ottavo, la piu' comune.
+UNIT = Fraction(1, 2)
+BARS_PER_LINE = 4
+DRUM_CHANNEL = 10
+
+_SHARP_ORDER = "FCGDAEB"
+_MAJOR_NAMES = {-7: "Cb", -6: "Gb", -5: "Db", -4: "Ab", -3: "Eb", -2: "Bb", -1: "F", 0: "C",
+                1: "G", 2: "D", 3: "A", 4: "E", 5: "B", 6: "F#", 7: "C#"}
+_MINOR_NAMES = {-7: "Abm", -6: "Ebm", -5: "Bbm", -4: "Fm", -3: "Cm", -2: "Gm", -1: "Dm", 0: "Am",
+                1: "Em", 2: "Bm", 3: "F#m", 4: "C#m", 5: "G#m", 6: "D#m", 7: "A#m"}
+_ARTICULATIONS = {"staccato": ".", "mute": "!wedge!", "legato": "!tenuto!"}
+_DECORATIONS = {"accent": "!accent!", "marcato": "!marcato!", "tenuto": "!tenuto!", "fermata": "!fermata!",
+                "tr": "!trill!", "mordent": "!lowermordent!", "turn": "!turn!",
+                "arp": "!arpeggio!", "staccatissimo": "!wedge!", "sfz": "!sfz!", "fp": "!fp!",
+                "trem": "!///!", "harmonic": "!open!"}
+
+
+def key_name(key: str) -> str:
+    """La tonalita' del progetto come valore di K: ('C', 'Am', 'Bb', 'F#m')."""
+    found = key_fifths(key)
+    if not found:
+        return "C"
+    fifths, mode = found
+    return (_MINOR_NAMES if mode == "minor" else _MAJOR_NAMES)[fifths]
+
+
+def key_alters(fifths: int) -> Dict[str, int]:
+    """Alterazione in chiave di ogni nota (lettera maiuscola -> -1/0/+1)."""
+    alters = {step: 0 for step in "ABCDEFG"}
+    for step in (_SHARP_ORDER[:fifths] if fifths > 0 else _SHARP_ORDER[::-1][:-fifths]):
+        alters[step] = 1 if fifths > 0 else -1
+    return alters
+
+
+def length_suffix(units: Fraction) -> str:
+    """Il moltiplicatore di durata ABC ('', '2', '3/2', '/2', '/4')."""
+    if units == 1:
+        return ""
+    if units.denominator == 1:
+        return str(units.numerator)
+    if units.numerator == 1:
+        return "/" if units.denominator == 2 else f"/{units.denominator}"
+    return f"{units.numerator}/{units.denominator}"
+
+
+def pitch_text(step: str, alter: int, octave: int, bar_alters: Dict[str, int],
+               signature: Dict[str, int]) -> str:
+    """Una nota ABC: l'alterazione solo se diversa da quella in vigore
+    (armatura, o alterazione precedente nella battuta: per lo standard vale
+    per quella nota in tutte le ottave, %%propagate-accidentals pitch)."""
+    current = bar_alters.get(step, signature[step])
+    accidental = ""
+    if alter != current:
+        accidental = {2: "^^", 1: "^", 0: "=", -1: "_", -2: "__"}[alter]
+        bar_alters[step] = alter
+    if octave >= 5:
+        return accidental + step.lower() + "'" * (octave - 5)
+    return accidental + step + "," * (4 - octave)
+
+
+def chord_symbol(symbol: str, bass: Optional[str]) -> str:
+    text = symbol.replace("♭", "b")
+    if len(text) > 1 and text[1] == "-":
+        text = text[0] + "b" + text[2:]
+    if bass:
+        text += "/" + bass.replace("♭", "b").replace("-", "b")
+    return '"' + text.replace('"', "") + '"'
+
+
+def _drum_items(items: List[_Item]) -> List[_Item]:
+    """I colpi di batteria come note: la nota GM del suono (canale 10)."""
+    out = []
+    for item in items:
+        pitches = sorted({PERCUSSION_MAP.get(d, 38) for d in item.drums})
+        graces = tuple((tuple(_spell_midi(PERCUSSION_MAP.get(d, 38), False) for d in drums), (), slash)
+                       for _pitches, drums, slash in item.graces)
+        out.append(dataclasses.replace(item, pitches=[_spell_midi(p, False) for p in pitches], drums=[],
+                                       graces=graces))
+    return out
+
+
+def _clef_text(sign: str, octave_change: int) -> str:
+    if sign == "percussion":
+        return "perc"
+    name = "treble" if sign == "G" else "bass"
+    return name + ("-8" if octave_change < 0 else "+8" if octave_change > 0 else "")
+
+
+def _lyric_syllable(entry: _Entry, verse: int = 1) -> str:
+    """La sillaba w: di una nota nella strofa 'verse': '*' senza testo, '_'
+    per la nota legata che prosegue (lo standard le conta come note distinte)."""
+    if not entry.first_of_item:
+        return "_ "
+    syllable = _item_syllables(entry.item).get(verse)
+    if not syllable:
+        return "* "
+    if syllable == "_":
+        return "_ "
+    text = syllable.replace(" ", "~").replace("*", "\\*")
+    return text if text.endswith("-") and len(text) > 1 else text + " "
+
+
+class _Voice:
+    def __init__(self, vid: str, name: str, clef: str, program: Optional[int], drums: bool,
+                 items: List[_Item], first: bool, transpose: int):
+        self.vid = vid
+        self.name = name
+        self.clef = clef
+        self.program = program
+        self.drums = drums
+        self.items = items
+        self.first = first              # prima voce del pentagramma (pause visibili)
+        self.transpose = transpose      # semitoni fra suono e scrittura (chiave all'ottava)
+        self.directions: List[_Direction] = []
+        self.verses = sorted({n for i in items for n in _item_syllables(i)})
+        self.has_lyrics = bool(self.verses)
+
+
+def _entry_text(entry: _Entry, voice: _Voice, bar_alters, signature) -> str:
+    units = entry.duration / UNIT
+    if entry.tuplet:
+        actual, normal = entry.tuplet
+        units = units * actual / normal
+    out = "".join(entry.directions)
+    if entry.item is None:
+        rest = "z" if voice.first else "x"
+        return out + rest + length_suffix(units)
+    if entry.first_of_item and entry.item.slur == "start":
+        out += "("
+    if entry.first_of_item and entry.item.articulation in _ARTICULATIONS:
+        out += _ARTICULATIONS[entry.item.articulation]
+    if entry.first_of_item:
+        out += "".join(_DECORATIONS[d] for d in entry.item.decorations if d in _DECORATIONS)
+    if entry.first_of_item and entry.item.graces:
+        # {/g} acciaccatura, {g} appoggiatura; un abbellimento di piu' note si
+        # scrive come sequenza (le note di un abbellimento ABC sono singole)
+        slash = "/" if entry.item.graces[0][2] else ""
+        out += "{" + slash + "".join(pitch_text(p.step, p.alter, p.octave + voice.transpose // 12, bar_alters,
+                                                  signature)
+                                       for pitches, _drums, _slash in entry.item.graces for p in pitches) + "}"
+    notes = [pitch_text(p.step, p.alter, p.octave + voice.transpose // 12, bar_alters, signature)
+             for p in entry.item.pitches]
+    body = notes[0] if len(notes) == 1 else "[" + "".join(notes) + "]"
+    slur_end = ")" if not entry.tie_start and entry.item.slur == "stop" else ""
+    return out + body + length_suffix(units) + ("-" if entry.tie_start else "") + slur_end
+
+
+def _measure_text(entries: List[_Entry], voice: _Voice, signature) -> Tuple[str, Dict[int, List[str]]]:
+    """La battuta di una voce e le sue sillabe, per strofa."""
+    parts: List[str] = []
+    syllables: Dict[int, List[str]] = {n: [] for n in voice.verses}
+    bar_alters: Dict[str, int] = {}
+    in_tuplet = False
+    for i, entry in enumerate(entries):
+        if entry.tuplet_mark == "start":
+            count = next(k for k, e in enumerate(entries[i:]) if e.tuplet_mark == "stop") + 1
+            actual, normal = entry.tuplet
+            parts.append(f"({actual}:{normal}:{count}")
+            in_tuplet = True
+        elif entry.tuplet and not in_tuplet:
+            # tuplet isolata (una nota sola, es. una pausa di terzina)
+            actual, normal = entry.tuplet
+            parts.append(f"({actual}:{normal}:1")
+        text = _entry_text(entry, voice, bar_alters, signature)
+        if entry.tuplet_mark == "stop":
+            in_tuplet = False
+        joined = entry.beam in ("begin", "continue")
+        parts.append(text + ("" if joined else " "))
+        if entry.item is not None:
+            for n in voice.verses:
+                syllables[n].append(_lyric_syllable(entry, n))
+    return "".join(parts).rstrip(), syllables
+
+
+def project_to_abc(project: "Song", only_audible: bool = True,
+                   tracks: Optional[List["Part"]] = None, midi_dir: Optional[str] = None) -> str:
+    """Il progetto come brano ABC (X:1), una voce per pentagramma."""
+    from .timing import build_metrica_beat_map, build_tempo_beat_map
+
+    if tracks is None:
+        tracks = project.audible_tracks() if only_audible else project.tracks
+    tracks = [t for t in tracks if not t.is_audio]
+    events_by_track = {t.name: t.parsed_events(project.patterns, midi_dir=midi_dir, meter=project.meter()) for t in tracks}
+    key = key_fifths(project.key)
+    flats = bool(key and key[0] < 0)
+    signature = key_alters(key[0] if key else 0)
+
+    grid = None
+    for _attempt in range(2):
+        parsed = {t.name: _track_items(events_by_track[t.name], t.instrument, flats, grid) for t in tracks}
+        tempo_map = [(_frac(b, grid), bpm) for b, bpm in
+                     build_tempo_beat_map(project, tracks=tracks, events_by_track=events_by_track)]
+        end = max([i.end for items, _ in parsed.values() for i in items] + [Fraction(0)])
+        measures = _measures(build_metrica_beat_map(project), end, getattr(project, "pickup", 0))
+        times = [m[0] for m in measures] + [t for t, _ in tempo_map]
+        for items, pedals in parsed.values():
+            times += [i.start for i in items] + [i.end for i in items] + [t for t, _ in pedals]
+        if _grid_divisions(times):
+            break
+        grid = QUANT_GRID
+
+    layout = _repeat_layout(measures, [r for t in tracks for r in _track_repeats(events_by_track[t.name], grid)],
+                            [parsed[t.name][0] for t in tracks])
+    voices: List[_Voice] = []
+    score: List[str] = []
+    for n, track in enumerate(tracks, 1):
+        items, _pedals = parsed[track.name]   # il pedale non e' nello standard ABC 2.1
+        _drop_repeated_harmonies(items)
+        instrument = track.instrument
+        drums = instrument.is_percussion
+        clefs = _clefs(track, items)
+        if drums:
+            items = _drum_items(items)
+        if len(clefs) == 2:
+            upper = [dataclasses.replace(i, pitches=[p for p in i.pitches if p.midi >= 60])
+                     for i in items if any(p.midi >= 60 for p in i.pitches)]
+            lower = [dataclasses.replace(i, pitches=[p for p in i.pitches if p.midi < 60], harmony=None,
+                                         lyric=i.lyric if not any(p.midi >= 60 for p in i.pitches) else None)
+                     for i in items if any(p.midi < 60 for p in i.pitches)]
+            staff_items = [upper, lower]
+        else:
+            staff_items = [items]
+
+        directions: List[_Direction] = []
+        if n == 1:
+            directions += [_Direction(t, f"[Q:1/4={bpm}]") for t, bpm in tempo_map if t > 0]
+        directions += [_Direction(i.start, chord_symbol(*i.harmony)) for i in items if i.harmony]
+        directions += [_Direction(t, chord_symbol(symbol, bass))
+                       for t, symbol, bass in _track_harmonies(events_by_track[track.name], grid)]
+        directions += [_Direction(t, '"^' + words.replace('"', "'") + '"')
+                       for t, words in _track_texts(events_by_track[track.name], grid)]
+        directions += [_Direction(t, {"segno": "!segno!", "coda": "!coda!"}.get(name)
+                                  or '"^' + NAVIGATION_WORDS.get(name, name) + '"')
+                       for t, name in _track_navigation(events_by_track[track.name], grid)]
+        if not drums:
+            first_voice = min((i.voice for i in items), default=1)
+            directions += [_Direction(t, f"!{mark}!") for t, mark in
+                           _dynamic_changes(_monophonic([i for i in items if i.voice == first_voice]))]
+        merged: Dict[Fraction, str] = {}
+        for d in sorted(directions, key=lambda d: (d.time, not d.xml.startswith("["))):
+            merged[d.time] = merged.get(d.time, "") + d.xml
+        directions = [_Direction(t, text) for t, text in sorted(merged.items())]
+
+        staves = []
+        for s, s_items in enumerate(staff_items):
+            by_voice: Dict[int, List[_Item]] = {}
+            for item in s_items:
+                by_voice.setdefault(item.voice, []).append(item)
+            sign, _line, octave_change = clefs[s]
+            ids = []
+            for k, (_v, v_items) in enumerate(sorted(by_voice.items()) or [(1, [])]):
+                v_items = _monophonic(v_items)
+                _mark_lyrics(v_items)
+                vid = f"T{n}" + ("" if s == 0 else "b") + ("" if k == 0 else f"v{k + 1}")
+                name = track.name if s == 0 and k == 0 else ""
+                voice = _Voice(vid, name, _clef_text(sign, octave_change), instrument.gm_program,
+                               drums, v_items, k == 0, -12 * octave_change)
+                if s == 0 and k == 0:
+                    voice.directions = directions
+                voices.append(voice)
+                ids.append(vid)
+            staves.append(ids[0] if len(ids) == 1 else "(" + " ".join(ids) + ")")
+        score.append(staves[0] if len(staves) == 1 else "{" + " | ".join(staves) + "}")
+
+    first_sig = f"{measures[0][2]}/{measures[0][3]}"
+    bpm = tempo_map[0][1] if tempo_map and tempo_map[0][0] == 0 else round(project.tempo_bpm)
+    out = ["X:1", f"T:{getattr(project, 'title', '') or project.name}"]
+    if getattr(project, "composer", ""):
+        out.append(f"C:{project.composer}")
+    if getattr(project, "lyricist", ""):
+        out.append(f"C:{project.lyricist} (lyrics)")
+    out += [f"M:{first_sig}", "L:1/8", f"Q:1/4={bpm}"]
+    key_changes = dict(song_key_changes(project))
+    if len(voices) > 1:
+        out.append("%%score " + " ".join(score))
+    for voice in voices:
+        line = f"V:{voice.vid} clef={voice.clef}"
+        if voice.name:
+            line += ' name="' + voice.name.replace('"', "'") + '"'
+        out.append(line)
+    out.append(f"K:{key_name(project.key)}")
+
+    for voice in voices:
+        out.append(f"V:{voice.vid}")
+        out.append(f"%%MIDI channel {DRUM_CHANNEL}" if voice.drums else f"%%MIDI program {voice.program}")
+        line: List[str] = []
+        syllables: Dict[int, List[str]] = {n: [] for n in voice.verses}
+        previous_sig = (measures[0][2], measures[0][3])
+        voice_signature = signature
+        for number, (m_index, marks) in enumerate(layout, 1):
+            m_start, m_len, num, den = measures[m_index]
+            changes_key = m_start in key_changes and number > 1 and not voice.drums
+            if changes_key:
+                voice_signature = key_alters(key_fifths(key_changes[m_start])[0])
+            entries = _staff_entries(voice.items, voice.directions, m_start, m_len, num, den)
+            text, bar_syllables = _measure_text(entries, voice, voice_signature)
+            if (num, den) != previous_sig:
+                text = f"[M:{num}/{den}] " + text
+                previous_sig = (num, den)
+            if changes_key:
+                text = f"[K:{key_name(key_changes[m_start])}] " + text
+            if marks.ending_start:
+                text = f"[{marks.ending_start} " + text
+            if number == 1 and marks.forward:
+                text = "|: " + text
+            last = number == len(layout)
+            following = layout[number][1] if not last else None
+            if marks.backward:
+                bar = "::" if following is not None and following.forward else ":|"
+            elif following is not None and following.forward:
+                bar = "|:"
+            else:
+                bar = "|]" if last else "|"
+            line.append(text + " " + bar)
+            for n in voice.verses:
+                syllables[n] += bar_syllables[n]
+            if number % BARS_PER_LINE == 0 or last:
+                out.append(" ".join(line))
+                # una riga w: per strofa, sempre (anche vuota): per lo standard
+                # la successiva si allinea dopo le note di questa
+                for n in voice.verses:
+                    words = "".join(syllables[n]).split(" ")
+                    while words and words[-1] in ("*", ""):
+                        words.pop()
+                    out.append(("w: " + " ".join(words)).rstrip())
+                line, syllables = [], {n: [] for n in voice.verses}
+    return "\n".join(out) + "\n"
+
+
+def export_project_to_abc(project: "Song", path: str, only_audible: bool = True,
+                          tracks: Optional[List["Part"]] = None, midi_dir: Optional[str] = None) -> str:
+    """Scrive in path il brano ABC del progetto (vedi project_to_abc): le
+    stesse tracce dell'esportazione MIDI e MusicXML."""
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(project_to_abc(project, only_audible=only_audible, tracks=tracks, midi_dir=midi_dir))
+    return path