tonalis 0.1.0__tar.gz

tonalis-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DRYCodeWorks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tonalis-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: tonalis
+Version: 0.1.0
+Summary: Tonalis — a generic, format-agnostic music-harmony DSL (parse/lint/AST/JSON/text).
+License: MIT License
+        
+        Copyright (c) 2026 DRYCodeWorks
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/drycode/tonalis
+Project-URL: Repository, https://github.com/drycode/tonalis
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tonalis-music-dsl==0.1.0
+Dynamic: license-file
+
+# tonalis
+
+A generic, format-agnostic music-harmony DSL for lead sheets: parse chord
+charts to a canonical AST, lint them with structured findings, and render back
+to canonical text or JSON. This is the Python reference implementation;
+TypeScript (`tonalis` on npm) and Rust (`tonalis` on crates.io) ports conform
+to the same normative spec and a shared 255-case conformance suite.
+
+Music-theory questions (chord validity, scales, keys) are delegated to the
+pure [`tonalis-music-dsl`](https://pypi.org/project/tonalis-music-dsl/) theory library.
+
+## Install
+
+```bash
+pip install tonalis
+```
+
+## Use
+
+```python
+from tonalis import parse_dsl, lint, serialize, to_json
+
+result = parse_dsl(open("chart.txt").read())
+findings = list(result.findings) + (lint(result.chart) if result.chart else [])
+chart = result.chart            # a LeadSheet AST
+json_obj = to_json(chart)       # canonical JSON (a dict)
+text = serialize(chart)         # canonical text rendering
+```
+
+A small CLI is included: `python -m tonalis chart.txt` prints lint findings
+(exit 1 if any error).
+
+## Links
+
+- Source, spec, docs, and conformance suite: <https://github.com/drycode/tonalis>
+- License: MIT

tonalis-0.1.0/README.md

@@ -0,0 +1,36 @@
+# tonalis
+
+A generic, format-agnostic music-harmony DSL for lead sheets: parse chord
+charts to a canonical AST, lint them with structured findings, and render back
+to canonical text or JSON. This is the Python reference implementation;
+TypeScript (`tonalis` on npm) and Rust (`tonalis` on crates.io) ports conform
+to the same normative spec and a shared 255-case conformance suite.
+
+Music-theory questions (chord validity, scales, keys) are delegated to the
+pure [`tonalis-music-dsl`](https://pypi.org/project/tonalis-music-dsl/) theory library.
+
+## Install
+
+```bash
+pip install tonalis
+```
+
+## Use
+
+```python
+from tonalis import parse_dsl, lint, serialize, to_json
+
+result = parse_dsl(open("chart.txt").read())
+findings = list(result.findings) + (lint(result.chart) if result.chart else [])
+chart = result.chart            # a LeadSheet AST
+json_obj = to_json(chart)       # canonical JSON (a dict)
+text = serialize(chart)         # canonical text rendering
+```
+
+A small CLI is included: `python -m tonalis chart.txt` prints lint findings
+(exit 1 if any error).
+
+## Links
+
+- Source, spec, docs, and conformance suite: <https://github.com/drycode/tonalis>
+- License: MIT

tonalis-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tonalis"
+version = "0.1.0"
+description = "Tonalis — a generic, format-agnostic music-harmony DSL (parse/lint/AST/JSON/text)."
+requires-python = ">=3.11"
+readme = "README.md"
+license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+]
+dependencies = ["tonalis-music-dsl==0.1.0"]
+
+[project.urls]
+Homepage = "https://github.com/drycode/tonalis"
+Repository = "https://github.com/drycode/tonalis"
+
+[tool.setuptools]
+packages = ["tonalis"]
+
+[tool.setuptools.package-data]
+tonalis = ["GRAMMAR.md"]

tonalis-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tonalis-0.1.0/tonalis/GRAMMAR.md

@@ -0,0 +1,118 @@
+# Tonalis DSL v1 — Grammar Reference
+
+Emit a chart in this DSL. Output **only** the DSL, nothing else.
+
+## Header (required keys: title, key, time)
+
+```
+title: All The Things You Are
+composer: Jerome Kern
+style: Medium Swing
+key: Ab
+time: 4/4
+```
+
+Rules: one `key: value` per line; **no `=` in any value**; `time` is `n/d`.
+
+## Sections and measures
+
+Sections are `[A]`, `[B]`, `[C]`, `[D]`, `[Intro]`/`[i]`, `[Verse]`/`[v]`.
+Measures are separated by `|`. Chords inside a measure split the bar evenly;
+add `:N` for an explicit beat count.
+
+```
+[A]
+| F-7 | Bb7 | Eb^7 | Ab^7 |
+| D-7 G7 | C^7 | C^7 | C^7 |
+```
+
+## Repeats, endings, navigation
+
+`{ ... }` is a repeat; `1.`/`2.` mark first/second endings; `@segno`, `@coda`,
+`[time: 3/4]` mid-chart, and `<staff text>` are supported. `@break` (or
+`@newline`) on its own line forces the next section/measure onto a new line
+(a vertical-space / line-break layout hint); use it for layout, e.g. to put an intro on its own row.
+
+Layout model: grid-style chart renderers commonly display a fixed **4-cell bar**
+regardless of meter (the time signature affects playback only) and auto-wrap
+every **4 bars per row**.
+So rows come out clean by default; emit `@break` only where a section must
+start on a fresh row after a short tail (e.g. a 2-bar second ending). Bars
+holding 4+ chords render wider than the grid — unavoidable in v1.
+For a D.S./D.C. al Coda: `@segno` marks the jump-back point, `@tocoda` (placed
+*after* a measure) marks the "To Coda" jump-from, and `@coda` marks the coda
+section (the destination). `@fine` marks the Fine (end) point for a D.C./D.S. al Fine.
+
+```
+[Intro]
+| D-7 | G7 |
+@break
+[A]
+{ | C^7 | A-7 | 1. D-7 | G7 | }
+| 2. D-7 | G7 |
+```
+
+## Chord vocabulary
+
+Quality: `-` minor, `^` major-7, `o` dim, `h` half-dim, `+` aug, `sus`.
+Extensions: `b5 #5 6 b9 9 #9 11 #11 b13 13`. No-chord: `N.C.`.
+
+The following are all VALID chord tokens (the drift gate asserts each passes
+the parser's `is_valid_chord`):
+
+<!-- valid-chords -->
+```
+C
+C^7
+A-7
+G7
+D-7
+F^7
+Bbo7
+Eh7
+C+
+Csus
+C7b9
+G7#5
+F#-7b5
+Ab^7
+C/E
+N.C.
+```
+<!-- /valid-chords -->
+
+## Banned constructs
+
+The following DSL snippets MUST fail to compile (the drift gate asserts each
+yields an error finding):
+
+<!-- banned-dsl -->
+```
+title: Has = Sign
+key: C
+time: 4/4
+
+[A]
+| C |
+---
+title: Bad Section
+key: C
+time: 4/4
+
+[Z]
+| C |
+---
+title: Bad Time
+key: C
+time: 9
+---
+title: Bad Chord
+key: C
+time: 4/4
+
+[A]
+| Zxq9 |
+```
+<!-- /banned-dsl -->
+
+Each banned snippet above is separated by a line containing only `---`.

tonalis-0.1.0/tonalis/__init__.py

@@ -0,0 +1,36 @@
+"""Pure lead-sheet / chord-chart language core (parse/lint/AST/JSON/text). Format-agnostic."""
+
+from tonalis.ast import (
+    Barline,
+    Cell,
+    LeadSheet,
+    LintFinding,
+    Measure,
+    ParseResult,
+    Section,
+    SectionKind,
+)
+from tonalis.chords import is_valid_chord
+from tonalis.lint import lint
+from tonalis.parser import parse_dsl
+from tonalis.serialize import ast_from_json, ast_to_json, from_json, to_json
+from tonalis.serialize_text import serialize
+
+__all__ = [
+    "parse_dsl",
+    "lint",
+    "is_valid_chord",
+    "serialize",
+    "ast_to_json",
+    "ast_from_json",
+    "to_json",
+    "from_json",
+    "LeadSheet",
+    "Cell",
+    "Measure",
+    "Section",
+    "SectionKind",
+    "Barline",
+    "LintFinding",
+    "ParseResult",
+]

tonalis-0.1.0/tonalis/__main__.py

@@ -0,0 +1,26 @@
+import argparse
+import sys
+
+from tonalis.parser import parse_dsl
+from tonalis.lint import lint
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(prog="tonalis", description="Lint/parse a lead-sheet DSL chart.")
+    ap.add_argument("file")
+    ap.add_argument("--lint-only", action="store_true")
+    args = ap.parse_args(argv)
+    try:
+        text = open(args.file, encoding="utf-8").read()
+    except OSError as e:
+        print(f"error: cannot read {args.file}: {e}", file=sys.stderr)
+        return 2
+    pr = parse_dsl(text)
+    findings = list(pr.findings) + (lint(pr.chart) if pr.chart else [])
+    for f in findings:
+        print(f"{f.severity}:{f.line}: [{f.code}] {f.message}", file=sys.stderr)
+    return 1 if any(f.severity == "error" for f in findings) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tonalis-0.1.0/tonalis/ast.py

@@ -0,0 +1,93 @@
+"""DSL abstract syntax — frozen-ish dataclasses produced by the parser, consumed by the
+linter and a downstream codec.
+
+Phase 2: the IR is NEUTRAL. The root is ``LeadSheet`` (was ``DslChart``); a section carries a
+neutral ``kind`` enum (derived by the parser from the bracket name); a measure carries a
+``barline`` enum (was the raw ``bar_close`` glyph) plus an opaque ``hints`` list (where
+``@break`` lives — it has no lead-sheet semantics). No field stores a format-specific value; a
+downstream codec maps kind/barline/hints to the target format's section/barline markers itself.
+"""
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Optional, Tuple
+
+
+class SectionKind(str, Enum):
+    """Neutral section role, derived by the parser from the bracket name."""
+    A = "a"
+    B = "b"
+    C = "c"
+    D = "d"
+    INTRO = "intro"
+    VERSE = "verse"
+
+
+class Barline(str, Enum):
+    """Neutral right-barline. ``'|'`` -> NORMAL, ``'}'`` -> REPEAT_END, ``'Z'``/``'||'`` -> FINAL."""
+    NORMAL = "normal"
+    REPEAT_END = "repeat_end"
+    FINAL = "final"
+
+
+@dataclass
+class Cell:
+    chord: str
+    beats: Optional[int] = None  # explicit :N, else None (even split of the bar)
+    alt: Optional[str] = None  # raw "(A-7 D7)" alt-chord text, if any
+
+    @property
+    def chord_obj(self):
+        """Lazy MusicDSL Chord for a present chord token; None for empty / no-chord /
+        bare-slash cells; raises InvalidChordStringException for a malformed-present token."""
+        from music_dsl.domain.chords.chord import Chord  # lazy: keeps the dep at use-time
+        t = (self.chord or "").replace("*", "")
+        if not t or t in ("N.C.", "n") or t.startswith("/"):
+            return None
+        return Chord(t)
+
+    @property
+    def chord_obj_or_none(self):
+        """Non-raising form of chord_obj (None for malformed tokens too)."""
+        from music_dsl.domain.chords.abstract_chord import InvalidChordStringException
+        try:
+            return self.chord_obj
+        except InvalidChordStringException:
+            return None
+
+
+@dataclass
+class Measure:
+    cells: List[Cell] = field(default_factory=list)
+    ending: Optional[int] = None  # 1./2. nth-ending number
+    bar_open: bool = False  # preceded by '{'
+    barline: Barline = Barline.NORMAL  # neutral right-barline (was bar_close: str)
+    nav: Tuple = ()  # ('segno',), ('coda',), ('fine',), ('text', '<...>'), ('time', (n, d))
+    hints: Tuple[str, ...] = ()  # opaque render-hints, e.g. ('break',); NO semantics
+    line: int = 0  # source line for findings
+
+
+@dataclass
+class Section:
+    label: str
+    kind: SectionKind  # neutral role (the parser derives it from the bracket name)
+    measures: List[Measure] = field(default_factory=list)
+
+
+@dataclass
+class LeadSheet:
+    meta: dict = field(default_factory=dict)  # title/composer/style/key/time
+    sections: List[Section] = field(default_factory=list)
+
+
+@dataclass
+class LintFinding:
+    severity: str  # "error" | "warning"
+    line: int
+    code: str
+    message: str
+
+
+@dataclass
+class ParseResult:
+    chart: Optional[LeadSheet]
+    findings: List[LintFinding] = field(default_factory=list)

tonalis-0.1.0/tonalis/chord_grammar.py

@@ -0,0 +1,4 @@
+"""Deprecated: chord validation moved to tonalis.chords (MusicDSL-backed).
+Kept as a shim so any `from tonalis.chord_grammar import is_valid_chord` still resolves.
+"""
+from tonalis.chords import is_valid_chord  # noqa: F401

tonalis-0.1.0/tonalis/chords.py

@@ -0,0 +1,39 @@
+"""Chord-token validation for the lead-sheet linter, standing on MusicDSL.
+
+Replaces ``chord_grammar``'s hand-rolled regex: the "is this a real chord" decision is
+delegated to MusicDSL's ``Chord()`` (the theory library is the single source of truth for
+what a chord is). The handful of non-chord lead-sheet tokens that ``Chord()`` rightly
+rejects but the linter must still accept are preserved here verbatim:
+
+  * ``N.C.`` / ``n`` — explicit no-chord markers.
+  * a standalone slash-bass continuation (``/A``) — a bass note carried over from the
+    previous chord, with no quality of its own.
+  * the augmented layout-star artifact (``Bb*7+*``) — lead-sheet notation sometimes glues a
+    ``*`` to a chord as a layout marker; strip it before validating.
+
+This module may import ``music_dsl`` (the theory lib tonalis stands on) per the Phase 1
+one-way dependency rule (leadsheet -> music_dsl); ``music_dsl`` must never import tonalis.
+"""
+
+import re
+
+from music_dsl.domain.chords.abstract_chord import InvalidChordStringException
+from music_dsl.domain.chords.chord import Chord
+
+_SLASH_BASS = re.compile(r"^/[A-G][b#]?$")  # standalone bass continuation, e.g. /A
+
+
+def is_valid_chord(token: str) -> bool:
+    """True iff the token is a well-formed chord OR a no-chord / bass marker."""
+    if token in ("N.C.", "n"):
+        return True
+    if not token:
+        return False
+    t = token.replace("*", "")  # tolerate the augmented layout-star artifact (Bb*7+*)
+    if _SLASH_BASS.match(t):
+        return True
+    try:
+        Chord(t)
+        return True
+    except InvalidChordStringException:
+        return False

tonalis-0.1.0/tonalis/lint.py

@@ -0,0 +1,140 @@
+"""DSL linter: structural + chord-grammar checks over a parsed LeadSheet.
+
+Errors block compilation; warnings don't. Uses the real chord grammar (chord_grammar) for
+bad-chord, not the permissive CST scanner.
+"""
+
+from tonalis.ast import Barline, LintFinding
+from tonalis.chords import is_valid_chord
+from tonalis.parser import MAX_CHORD_TOKEN_LEN
+
+# corpus-derived known-good uneven :N layouts (4/4); all-equal splits are always fine.
+_ALLOWED_UNEVEN = {(2, 1, 1), (1, 1, 1, 1), (1, 1, 2), (3, 1), (1, 3), (2, 2)}
+
+
+def _all_measures(chart):
+    return [(s, m) for s in chart.sections for m in s.measures]
+
+
+def _beat_pattern(measure, numerator):
+    """Per-cell beat counts: explicit :N consume their count; unannotated split the
+    remainder evenly. Returns (pattern_tuple, ok) where ok is False if it can't fill the bar.
+    """
+    cells = measure.cells
+    if not cells:
+        return (), True
+    explicit = sum(c.beats for c in cells if c.beats)
+    unannotated = [c for c in cells if not c.beats]
+    remainder = numerator - explicit
+    if unannotated:
+        if remainder <= 0 or remainder % len(unannotated) != 0:
+            return tuple(c.beats or 0 for c in cells), False
+        each = remainder // len(unannotated)
+        return tuple(c.beats if c.beats else each for c in cells), True
+    return tuple(c.beats for c in cells), explicit == numerator
+
+
+def lint(chart):
+    findings = []
+
+    def err(line, code, msg):
+        findings.append(LintFinding("error", line, code, msg))
+
+    def warn(line, code, msg):
+        findings.append(LintFinding("warning", line, code, msg))
+
+    measures = _all_measures(chart)
+    numerator = (chart.meta.get("time") or (4, 4))[0]
+
+    # repeats / endings balance, codas/segno, final bar, per-measure beats + chords
+    balance = n_coda = n_segno = 0
+    last_idx = len(measures) - 1
+    for idx, (section, m) in enumerate(measures):
+        for nav in m.nav:
+            if nav == ("coda",):
+                n_coda += 1
+            elif nav == ("segno",):
+                n_segno += 1
+            elif nav and nav[0] == "time":
+                numerator = nav[1][0]
+        if m.bar_open:
+            balance += 1
+        if m.barline == Barline.REPEAT_END:
+            if balance == 0:
+                err(m.line, "unbalanced-repeat", "'}' with no matching '{'")
+            else:
+                balance -= 1
+        if m.barline == Barline.FINAL and idx != last_idx:
+            warn(
+                m.line,
+                "mid-final-bar",
+                "final barline (Z/||) is not on the last measure",
+            )
+
+        # chords
+        for c in m.cells:
+            # skip is_valid_chord for tokens that already triggered token-too-long (parser
+            # error already emitted; MusicDSL would reject them as bad-chord too but the
+            # conformance spec treats over-length tokens as a single token-too-long error)
+            if c.chord and len(c.chord) <= MAX_CHORD_TOKEN_LEN and not is_valid_chord(c.chord):
+                err(m.line, "bad-chord", f"invalid chord token: {c.chord!r}")
+            if c.alt:
+                for tok in c.alt.strip("()").split():
+                    if not is_valid_chord(tok):
+                        err(m.line, "bad-chord", f"invalid alt chord: {tok!r}")
+
+        # empty measure
+        if not m.cells:
+            warn(m.line, "empty-measure", "measure has no chords (emitted as N.C.)")
+            continue
+
+        # beats. Pickup relaxation only excuses an UNDER-full first/last bar (anacrusis);
+        # an OVER-full bar is always wrong, even for a pickup.
+        pattern, ok = _beat_pattern(m, numerator)
+        total = sum(pattern)
+        is_pickup = idx in (0, last_idx)
+        if total > numerator:
+            err(m.line, "beat-sum", f"beats {pattern} overflow a {numerator}-beat bar")
+        elif not ok and not is_pickup:
+            err(
+                m.line,
+                "beat-sum",
+                f"beats {pattern} do not fill a {numerator}-beat bar",
+            )
+        elif ok and len(set(pattern)) > 1 and pattern not in _ALLOWED_UNEVEN:
+            warn(
+                m.line,
+                "beat-unsupported",
+                f"uneven beat layout {pattern} not in the allowlist; even-split fallback",
+            )
+
+    if balance != 0:
+        err(0, "unbalanced-repeat", f"{balance} unclosed '{{'")
+    # an empty section (header but no measures) silently drops in render — surface it
+    for section in chart.sections:
+        if not section.measures:
+            warn(
+                0,
+                "empty-section",
+                f"section [{section.label}] has no measures (dropped)",
+            )
+    # nth endings must belong to a repeat (a section with endings needs a bar_open)
+    for section in chart.sections:
+        has_open = any(m.bar_open for m in section.measures)
+        if any(m.ending for m in section.measures) and not has_open:
+            ln = next((m.line for m in section.measures if m.ending), 0)
+            err(ln, "ending-without-repeat", "nth ending outside a repeat block")
+    if n_coda > 2:
+        err(
+            0,
+            "coda-count",
+            f"{n_coda} coda points (max 2 — the encoder cannot flatten more)",
+        )
+    elif n_coda == 2 and n_segno == 0:
+        warn(
+            0,
+            "coda-needs-segno",
+            "2-coda jump without @segno (will play D.C., not D.S.)",
+        )
+
+    return findings

tonalis-0.1.0/tonalis/parser.py

@@ -0,0 +1,347 @@
+"""Bounded, single-pass DSL parser. Never eval/exec; limit violations are findings.
+
+DSL → ParseResult{LeadSheet, findings}. The parser records structure; the linter (lint.py)
+judges chord validity, beat sums, etc. Header values are read literally to end-of-line.
+"""
+
+import re
+
+from tonalis.ast import (
+    Barline,
+    Cell,
+    LeadSheet,
+    LintFinding,
+    Measure,
+    ParseResult,
+    Section,
+    SectionKind,
+)
+
+MAX_BYTES = 256 * 1024
+MAX_LINES = 5000
+MAX_LINE_LEN = 1000
+MAX_MEASURES = 2000
+MAX_CELLS_PER_MEASURE = 16
+MAX_CHORD_TOKEN_LEN = 50
+MAX_ALT_CHORD_TOKENS = 8
+# Numeric value cap (SPEC.md §1.4): a meter num/den, a :N beat count, and an ending number must be
+# <= MAX_METER. Exceeding it never reaches rendering, so no port can be driven into a multi-GB
+# " "-padding allocation or a fixed-width-int overflow.
+MAX_METER = 64
+
+# Line terminators (SPEC.md §1.1): ONLY \r\n, \n, \r. NOT Python's broader str.splitlines() set
+# (which also splits \v \f \x1c \x1d \x1e \x85 
 
) — those are ordinary characters here,
+# so all ports split identically.
+_LINE_SPLIT_RE = re.compile(r"\r\n|\r|\n")
+
+_REQUIRED = ("title", "key", "time")
+_META_KEYS = ("title", "composer", "style", "key", "time")
+_SECTIONS = {
+    "A": SectionKind.A,
+    "B": SectionKind.B,
+    "C": SectionKind.C,
+    "D": SectionKind.D,
+    "Intro": SectionKind.INTRO,
+    "i": SectionKind.INTRO,
+    "Verse": SectionKind.VERSE,
+    "v": SectionKind.VERSE,
+}
+_BARLINE_RE = re.compile(r"(\{|\}|\|\||\||Z)")
+_CELL_RE = re.compile(r"\([^)]*\)|\S+")  # a (alt) group, or a non-space run
+_INLINE_ALT_RE = re.compile(r"^([^(]+)(\([^)]*\))$")  # "G7(Db7)" -> chord + (alt)
+# ASCII digits only (SPEC.md §1.1): explicit [0-9] classes, never \d (Unicode-aware in Python).
+_ENDING_RE = re.compile(r"^([0-9]+)\.\s*(.*)$")
+_TIME_RE = re.compile(r"\[time:\s*([0-9]+)\s*/\s*([0-9]+)\s*\]\s*$")
+_SECTION_RE = re.compile(r"\[([A-Za-z]+)([0-9]*)\]\s*$")
+
+
+def _split_lines(text):
+    """SPEC.md §1.1 line split: ONLY \\r\\n, \\n, \\r (not Python's wider splitlines() set).
+
+    Mirrors ``str.splitlines()`` for these three forms — including dropping the trailing empty
+    element a terminal newline would otherwise leave — so the common case is byte-identical, but
+    a stray \\x1c/\\v/\\x85/etc. stays inside its line (an ordinary char), matching TS/Rust.
+    """
+    if text == "":
+        return []
+    parts = _LINE_SPLIT_RE.split(text)
+    if parts and parts[-1] == "":
+        parts.pop()
+    return parts
+
+
+def _is_ascii_digits(s):
+    """ASCII-only digit check (SPEC.md §1.1). Unlike ``str.isdigit()`` this rejects non-ASCII
+    digits (``٣``) AND numeric-but-non-decimal characters (``²``, which would crash ``int()``).
+    """
+    return s != "" and all("0" <= c <= "9" for c in s)
+
+
+def parse_dsl(text):
+    findings = []
+
+    def err(line, code, msg):
+        findings.append(LintFinding("error", line, code, msg))
+
+    def warn(line, code, msg):
+        findings.append(LintFinding("warning", line, code, msg))
+
+    if len(text.encode("utf-8", "replace")) > MAX_BYTES:
+        err(0, "too-big", "input exceeds MAX_BYTES")
+        return ParseResult(None, findings)
+    text = text.lstrip("")
+    lines = _split_lines(text)
+    if len(lines) > MAX_LINES:
+        err(0, "too-big", "too many lines")
+        return ParseResult(None, findings)
+    for n, raw in enumerate(lines, 1):
+        if len(raw) > MAX_LINE_LEN:
+            err(n, "too-big", "line too long")
+            return ParseResult(None, findings)
+
+    meta = {}
+    i, total = 0, len(lines)
+
+    def assign_meta(k, v, lineno):
+        # Header keys are singletons. Re-stating one is a duplicate (same value, redundant)
+        # or a conflict (different value, mutually exclusive) — never silently last-wins.
+        if k in meta:
+            if meta[k] == v:
+                warn(lineno, "duplicate-header", f"duplicate header {k!r}")
+            else:
+                err(
+                    lineno,
+                    "conflicting-header",
+                    f"conflicting header {k!r}: {meta[k]!r} vs {v!r}",
+                )
+            return  # keep the first value; a conflict already blocks compile
+        meta[k] = v
+
+    # --- header ---
+    while i < total:
+        raw = lines[i]
+        line = raw.strip()
+        if line == "" or line.startswith("#"):
+            i += 1
+            continue
+        if line[0] in "[|{":
+            break
+        m = re.match(r"([A-Za-z]+)\s*:\s*(.*)$", raw)  # value read literally to EOL
+        if not m:
+            break
+        key, val = m.group(1).lower(), m.group(2).rstrip()
+        if "=" in val:
+            err(i + 1, "meta-delimiter", f"'=' not allowed in metadata value: {val!r}")
+        if key == "time":
+            # ASCII digits only (SPEC.md §1.1); both components must be <= MAX_METER (§1.4).
+            tm = re.match(r"([0-9]+)\s*/\s*([0-9]+)$", val)
+            if tm and int(tm.group(1)) <= MAX_METER and int(tm.group(2)) <= MAX_METER:
+                assign_meta("time", (int(tm.group(1)), int(tm.group(2))), i + 1)
+            else:
+                err(i + 1, "bad-time", f"bad time signature: {val!r}")
+        elif key in _META_KEYS:
+            assign_meta(key, val, i + 1)
+        else:
+            warn(i + 1, "unknown-key", f"unknown header key: {key}")
+        i += 1
+
+    for k in _REQUIRED:
+        if k not in meta:
+            err(0, "missing-header", f"missing required header: {k}")
+    if meta.get("title", "") == "":
+        err(0, "missing-header", "title must be non-empty")
+
+    # --- body ---
+    sections = []
+    cur = None
+    pending_nav = []
+    pending_hints = []
+    measure_count = 0
+    current_time = meta.get("time", (4, 4))  # for redundant mid-chart [time:] detection
+
+    def ensure_section():
+        nonlocal cur
+        if cur is None:
+            cur = Section(label="A", kind=SectionKind.A)
+            sections.append(cur)
+        return cur
+
+    while i < total:
+        raw = lines[i]
+        line = raw.strip()
+        ln = i + 1
+        i += 1
+        if line == "" or line.startswith("#"):
+            continue
+        tm = _TIME_RE.match(line)
+        if line.startswith("[time") and tm:
+            n, d = int(tm.group(1)), int(tm.group(2))
+            if n > MAX_METER or d > MAX_METER:
+                # recognized [time:…] shape but the meter is out of range (SPEC.md §1.4/§4.4):
+                # reject it as bad-time; it contributes no nav.
+                err(ln, "bad-time", f"meter component exceeds MAX_METER: {n}/{d}")
+                continue
+            newt = (n, d)
+            if newt == current_time:
+                warn(
+                    ln,
+                    "redundant-time",
+                    f"[time: {newt[0]}/{newt[1]}] repeats the current meter",
+                )
+            current_time = newt
+            pending_nav.append(("time", newt))
+            continue
+        sec = _SECTION_RE.match(line)
+        if sec:
+            name = sec.group(1)
+            kind = _SECTIONS.get(name)
+            if kind is None:
+                err(
+                    ln,
+                    "unknown-section",
+                    f"unknown section {name!r}; allowed: A-D, Intro, Verse",
+                )
+                kind = SectionKind.A
+            cur = Section(label=name + sec.group(2), kind=kind)
+            sections.append(cur)
+            continue
+        if line.startswith("@"):
+            if "segno" in line:
+                pending_nav.append(("segno",))
+            elif "tocoda" in line or "to coda" in line or "to-coda" in line:
+                # "To Coda" jump-point: a Q AFTER the PRECEDING measure's chords (not the
+                # next one). Checked before "coda" because "tocoda" contains "coda".
+                if cur is not None and cur.measures:
+                    cur.measures[-1].nav = cur.measures[-1].nav + (("tocoda",),)
+                else:
+                    warn(
+                        ln, "tocoda-without-measure", "@tocoda has no preceding measure"
+                    )
+            elif "fine" in line:
+                pending_nav.append(("fine",))
+            elif "coda" in line:
+                pending_nav.append(("coda",))
+            elif "break" in line or "newline" in line:
+                # page-layout only — NO lead-sheet semantics. Demoted to an opaque
+                # render-hint (Phase 2 §3.3); a downstream codec reads it, text-target ignores it.
+                pending_hints.append("break")
+            else:
+                warn(ln, "unknown-nav", f"unknown @directive: {line}")
+            continue
+        if line.startswith("<") and line.endswith(">"):
+            pending_nav.append(("text", line))
+            continue
+        # otherwise: a measure line
+        section = ensure_section()
+        measures = _parse_measure_line(line, ln, err, warn)
+        for m in measures:
+            if pending_nav:
+                m.nav = tuple(pending_nav) + m.nav
+                pending_nav = []
+            if pending_hints:
+                m.hints = tuple(pending_hints) + m.hints
+                pending_hints = []
+            section.measures.append(m)
+            measure_count += 1
+            if measure_count > MAX_MEASURES:
+                err(ln, "too-big", "too many measures")
+                return ParseResult(LeadSheet(meta=meta, sections=sections), findings)
+
+    if not sections or all(not s.measures for s in sections):
+        err(0, "empty-chart", "no sections or measures")
+    return ParseResult(LeadSheet(meta=meta, sections=sections), findings)
+
+
+def _parse_measure_line(line, ln, err, warn):
+    parts = _BARLINE_RE.split(line)
+    measures = []
+    bar_open = False
+    buf = None
+    for p in parts:
+        if p == "{":
+            bar_open = True
+            continue
+        if p in ("|", "}", "||", "Z"):
+            if buf is not None and buf.strip() != "":
+                if p in ("||", "Z"):
+                    close = Barline.FINAL
+                elif p == "}":
+                    close = Barline.REPEAT_END
+                else:
+                    close = Barline.NORMAL
+                ending, cells = _parse_cells(buf, ln, err, warn)
+                measures.append(
+                    Measure(
+                        cells=cells,
+                        ending=ending,
+                        bar_open=bar_open,
+                        barline=close,
+                        line=ln,
+                    )
+                )
+                bar_open = False
+            elif p == "}" and measures:
+                measures[-1].barline = Barline.REPEAT_END
+            buf = None
+            continue
+        if p.strip() != "":
+            buf = p
+    if buf is not None and buf.strip() != "":
+        ending, cells = _parse_cells(buf, ln, err, warn)
+        measures.append(
+            Measure(
+                cells=cells, ending=ending, bar_open=bar_open, barline=Barline.NORMAL, line=ln
+            )
+        )
+    return measures
+
+
+def _parse_cells(content, ln, err, warn):
+    content = content.strip()
+    ending = None
+    m = _ENDING_RE.match(content)
+    if m:
+        ending = int(m.group(1))
+        content = m.group(2).strip()
+        # An ending number > MAX_METER (SPEC.md §1.4) is a typo and would otherwise overflow a
+        # fixed-width int in the ports; reject with the generic size-cap code.
+        if ending > MAX_METER:
+            err(ln, "too-big", f"ending number exceeds MAX_METER: {ending}")
+    cells = []
+    for tok in _CELL_RE.findall(content):
+        if tok.startswith("("):
+            if len(tok.strip("()").split()) > MAX_ALT_CHORD_TOKENS:
+                err(ln, "alt-too-long", "alt chord has too many tokens")
+            if cells:
+                cells[-1].alt = tok
+            else:
+                warn(ln, "alt-without-chord", f"alt group {tok} has no preceding chord")
+            continue
+        # Split an inline alt off the chord, e.g. "G7(Db7)" -> chord "G7" + alt "(Db7)"
+        # (lead-sheet notation writes alts with no space; the space-separated "G7 (Db7)" form is handled
+        # by the `tok.startswith("(")` branch above).
+        inline_alt = None
+        am = _INLINE_ALT_RE.match(tok)
+        if am:
+            tok, inline_alt = am.group(1), am.group(2)
+            if len(inline_alt.strip("()").split()) > MAX_ALT_CHORD_TOKENS:
+                err(ln, "alt-too-long", "alt chord has too many tokens")
+        chord, beats = tok, None
+        if ":" in tok:
+            chord, _, b = tok.partition(":")
+            # ASCII digits only (SPEC.md §1.1) — str.isdigit() accepts non-ASCII digits and
+            # numeric-but-non-decimal chars like '²' (which would crash int()). Cap at MAX_METER.
+            if _is_ascii_digits(b):
+                if int(b) > MAX_METER:
+                    err(ln, "bad-beats", f"beat count exceeds MAX_METER in {tok!r}")
+                else:
+                    beats = int(b)
+            else:
+                err(ln, "bad-beats", f"bad beat count in {tok!r} (expected :<digits>)")
+        if len(chord) > MAX_CHORD_TOKEN_LEN:
+            err(ln, "token-too-long", f"chord token too long: {chord[:20]}…")
+        cells.append(Cell(chord=chord, beats=beats, alt=inline_alt))
+        if len(cells) > MAX_CELLS_PER_MEASURE:
+            err(ln, "too-big", "too many cells in a measure")
+            break
+    return ending, cells

tonalis-0.1.0/tonalis/serialize.py

@@ -0,0 +1,152 @@
+"""Canonical IR <-> JSON serialization for the conformance suite.
+
+Phase 2: the JSON reflects the NEUTRAL IR and carries a top-level ``schema_version: 1``.
+``ast_from_json`` rejects an unknown major version. ``LeadSheet`` replaces ``DslChart``;
+``Section.kind`` replaces ``marker``; ``Measure.barline`` (enum) replaces ``bar_close`` (glyph);
+``Measure.hints`` is a new opaque string list. ``nav`` round-trips list<->tuple as before; the
+new ``fine`` nav item is a bare ``["fine"]``.
+"""
+
+from tonalis.ast import Barline, Cell, LeadSheet, Measure, Section, SectionKind
+
+SCHEMA_VERSION = 1
+
+
+def _meta_to_json(meta: dict) -> dict:
+    out = {}
+    for k, v in meta.items():
+        if k == "time" and isinstance(v, tuple):
+            out[k] = list(v)
+        else:
+            out[k] = v
+    return out
+
+
+def _meta_from_json(d: dict) -> dict:
+    out = {}
+    for k, v in d.items():
+        if k == "time" and isinstance(v, list):
+            out[k] = tuple(v)
+        else:
+            out[k] = v
+    return out
+
+
+def _nav_to_json(nav) -> list:
+    return [_nav_item_to_json(item) for item in nav]
+
+
+def _nav_item_to_json(item):
+    return [_nav_atom_to_json(a) for a in item]
+
+
+def _nav_atom_to_json(a):
+    if isinstance(a, tuple):
+        return list(a)
+    return a
+
+
+def _nav_from_json(nav) -> tuple:
+    return tuple(_nav_item_from_json(item) for item in nav)
+
+
+def _nav_item_from_json(item) -> tuple:
+    return tuple(_nav_atom_from_json(a) for a in item)
+
+
+def _nav_atom_from_json(a):
+    if isinstance(a, list):
+        return tuple(a)
+    return a
+
+
+def _cell_to_json(c: Cell) -> dict:
+    return {"chord": c.chord, "beats": c.beats, "alt": c.alt}
+
+
+def _cell_from_json(d: dict) -> Cell:
+    return Cell(chord=d["chord"], beats=d.get("beats"), alt=d.get("alt"))
+
+
+def _measure_to_json(m: Measure) -> dict:
+    return {
+        "cells": [_cell_to_json(c) for c in m.cells],
+        "ending": m.ending,
+        "bar_open": m.bar_open,
+        "barline": m.barline.value,
+        "nav": _nav_to_json(m.nav),
+        "hints": list(m.hints),
+        "line": m.line,
+    }
+
+
+def _measure_from_json(d: dict) -> Measure:
+    return Measure(
+        cells=[_cell_from_json(c) for c in d["cells"]],
+        ending=d.get("ending"),
+        bar_open=d.get("bar_open", False),
+        barline=Barline(d.get("barline", "normal")),
+        nav=_nav_from_json(d.get("nav", [])),
+        hints=tuple(d.get("hints", [])),
+        line=d.get("line", 0),
+    )
+
+
+def _section_to_json(s: Section) -> dict:
+    return {
+        "label": s.label,
+        "kind": s.kind.value,
+        "measures": [_measure_to_json(m) for m in s.measures],
+    }
+
+
+def _section_from_json(d: dict) -> Section:
+    return Section(
+        label=d["label"],
+        kind=SectionKind(d["kind"]),
+        measures=[_measure_from_json(m) for m in d["measures"]],
+    )
+
+
+def ast_to_json(chart: LeadSheet) -> dict:
+    """Serialize a :class:`LeadSheet` to the canonical JSON-able dict (SPEC.md §2.1)."""
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "meta": _meta_to_json(chart.meta),
+        "sections": [_section_to_json(s) for s in chart.sections],
+    }
+
+
+# Public aliases (spec §1.1 surface names): to_json / from_json.
+to_json = ast_to_json
+
+
+def _check_schema_version(d: dict) -> None:
+    """Reject an unknown/malformed ``schema_version`` with a clean ValueError.
+
+    Missing -> default 1 (accepted). Present must be the INTEGER ``SCHEMA_VERSION`` — a string
+    ``"2"``, ``null`` (Python ``None``), a bool, or any non-1 int are all rejected with a
+    ValueError (never a TypeError crash on ``int(None)``). Consistent with the TS/Rust ports.
+    """
+    if "schema_version" not in d:
+        return
+    version = d["schema_version"]
+    # bool is an int subclass but is never a valid version; reject it explicitly.
+    if isinstance(version, bool) or not isinstance(version, int) or version != SCHEMA_VERSION:
+        raise ValueError(
+            f"unsupported schema_version {version!r}; this build understands {SCHEMA_VERSION}"
+        )
+
+
+def ast_from_json(d: dict) -> LeadSheet:
+    """Inverse of :func:`ast_to_json`. Rejects an unknown major schema version, an unknown
+    ``Section.kind``, or an unknown ``Measure.barline`` with a clean ValueError (the canonical
+    JSON is a public interface — malformed input is rejected uniformly across all three ports)."""
+    _check_schema_version(d)
+    return LeadSheet(
+        meta=_meta_from_json(d.get("meta", {})),
+        sections=[_section_from_json(s) for s in d.get("sections", [])],
+    )
+
+
+from_json = ast_from_json

tonalis-0.1.0/tonalis/serialize_text.py

@@ -0,0 +1,111 @@
+"""Deterministic canonical-DSL pretty-printer: LeadSheet -> DSL text (Phase 2 §1.1).
+
+The inverse direction of ``parser.parse_dsl`` for the canonical form. ``parse(serialize(ir)) == ir``
+is gated by the conformance suite; this printer is the only place IR -> text lives.
+"""
+
+from tonalis.ast import Barline, LeadSheet, Measure, Section
+
+_HEADER_ORDER = ("title", "composer", "style", "key", "time")
+_BARLINE_GLYPH = {
+    Barline.NORMAL: "|",
+    Barline.REPEAT_END: "}",
+    Barline.FINAL: "||",
+}
+
+
+def _header(meta: dict) -> str:
+    out = []
+    for k in _HEADER_ORDER:
+        if k not in meta:
+            continue
+        v = meta[k]
+        if k == "time":
+            out.append(f"time: {v[0]}/{v[1]}")
+        else:
+            out.append(f"{k}: {v}")
+    return "\n".join(out)
+
+
+def _cell_str(cell) -> str:
+    s = cell.chord
+    if cell.beats is not None:
+        s += f":{cell.beats}"
+    if cell.alt:
+        # A single-token alt glues inline (`G7(Db7)`, the grammar's "inline alt, no space" form),
+        # but a MULTI-token alt carries an interior space (`(A-7 D7)`) and the glued form
+        # `G7(A-7 D7)` re-tokenizes wrong (the cell scanner `\([^)]*\)|\S+` breaks at the space).
+        # Emit the separated `chord (alt)` form so `parse(serialize(ir)) == ir` holds (SPEC §2.1).
+        s += (" " if " " in cell.alt else "") + cell.alt
+    return s
+
+
+def _nav_lines_before(m: Measure) -> list:
+    lines = []
+    for item in m.nav:
+        head = item[0]
+        if head == "segno":
+            lines.append("@segno")
+        elif head == "coda":
+            lines.append("@coda")
+        elif head == "fine":
+            lines.append("@fine")
+        elif head == "text":
+            lines.append(item[1])
+        elif head == "time":
+            lines.append(f"[time: {item[1][0]}/{item[1][1]}]")
+        # tocoda is emitted AFTER the measure (see _nav_after)
+    return lines
+
+
+def _nav_after(m: Measure) -> list:
+    return ["@tocoda" for item in m.nav if item and item[0] == "tocoda"]
+
+
+def _measure_str(m: Measure, *, first_on_line: bool) -> str:
+    # Canonical body line: a leading "| " opens the line, measures are "| "-joined, and each
+    # measure ends with its barline glyph. A repeat-open prefixes "{ ".
+    prefix = "{ " if m.bar_open else ("| " if first_on_line else "")
+    body = ""
+    if m.ending is not None:
+        body += f"{m.ending}. "
+    body += " ".join(_cell_str(c) for c in m.cells)
+    return f"{prefix}{body} {_BARLINE_GLYPH[m.barline]}"
+
+
+def _section_text(s: Section) -> str:
+    # One body line per section (parser-faithful): directives (@break/@segno/.../<text>) sit on
+    # their own line and FLUSH the in-progress measure line before them; @tocoda flushes after.
+    lines = [f"[{s.label}]"]
+    run = []  # measures accumulating on the current body line
+
+    def flush():
+        if run:
+            lines.append(" ".join(run))
+            run.clear()
+
+    for m in s.measures:
+        before = []
+        for h in m.hints:
+            if h == "break":
+                before.append("@break")
+        before.extend(_nav_lines_before(m))
+        if before:
+            flush()
+            lines.extend(before)
+        run.append(_measure_str(m, first_on_line=not run))
+        after = _nav_after(m)
+        if after:
+            flush()
+            lines.extend(after)
+    flush()
+    return "\n".join(lines)
+
+
+def serialize(chart: LeadSheet) -> str:
+    """Canonical DSL text for a LeadSheet (trailing newline; section blocks blank-line separated)."""
+    parts = [_header(chart.meta)]
+    for s in chart.sections:
+        parts.append("")  # blank line before each section
+        parts.append(_section_text(s))
+    return "\n".join(parts) + "\n"

tonalis-0.1.0/tonalis.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: tonalis
+Version: 0.1.0
+Summary: Tonalis — a generic, format-agnostic music-harmony DSL (parse/lint/AST/JSON/text).
+License: MIT License
+        
+        Copyright (c) 2026 DRYCodeWorks
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/drycode/tonalis
+Project-URL: Repository, https://github.com/drycode/tonalis
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tonalis-music-dsl==0.1.0
+Dynamic: license-file
+
+# tonalis
+
+A generic, format-agnostic music-harmony DSL for lead sheets: parse chord
+charts to a canonical AST, lint them with structured findings, and render back
+to canonical text or JSON. This is the Python reference implementation;
+TypeScript (`tonalis` on npm) and Rust (`tonalis` on crates.io) ports conform
+to the same normative spec and a shared 255-case conformance suite.
+
+Music-theory questions (chord validity, scales, keys) are delegated to the
+pure [`tonalis-music-dsl`](https://pypi.org/project/tonalis-music-dsl/) theory library.
+
+## Install
+
+```bash
+pip install tonalis
+```
+
+## Use
+
+```python
+from tonalis import parse_dsl, lint, serialize, to_json
+
+result = parse_dsl(open("chart.txt").read())
+findings = list(result.findings) + (lint(result.chart) if result.chart else [])
+chart = result.chart            # a LeadSheet AST
+json_obj = to_json(chart)       # canonical JSON (a dict)
+text = serialize(chart)         # canonical text rendering
+```
+
+A small CLI is included: `python -m tonalis chart.txt` prints lint findings
+(exit 1 if any error).
+
+## Links
+
+- Source, spec, docs, and conformance suite: <https://github.com/drycode/tonalis>
+- License: MIT

tonalis-0.1.0/tonalis.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+tonalis/GRAMMAR.md
+tonalis/__init__.py
+tonalis/__main__.py
+tonalis/ast.py
+tonalis/chord_grammar.py
+tonalis/chords.py
+tonalis/lint.py
+tonalis/parser.py
+tonalis/serialize.py
+tonalis/serialize_text.py
+tonalis.egg-info/PKG-INFO
+tonalis.egg-info/SOURCES.txt
+tonalis.egg-info/dependency_links.txt
+tonalis.egg-info/requires.txt
+tonalis.egg-info/top_level.txt

tonalis-0.1.0/tonalis.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tonalis-0.1.0/tonalis.egg-info/requires.txt

@@ -0,0 +1 @@
+tonalis-music-dsl==0.1.0

tonalis-0.1.0/tonalis.egg-info/top_level.txt

@@ -0,0 +1 @@
+tonalis