Make a bundle reopenable, and number slices
A bundle was a one-way trip. The slice images are output and the cuts that produced them lived only in the producer's own project file, so a bundle someone handed you meant cutting the score again from scratch. The manifest now carries the geometry, in a `source` block: per page the cut polylines, skew, levels and content rectangle, all in normalised coordinates so they survive any render resolution, and per slice the page and slot it came from. Discards are stated by omission — a slot no slice claims was discarded — since shipping a discarded slice's image would defeat discarding it. `noteman-slicer open song.zip` unpacks the archived PDF, rebuilds the project from that geometry, restores markers, engravings and the title block, and opens the editor. Jump destinations go back from an array index to the (page, slot) the editor works in. The images in the zip are discarded: the PDF is what the pipeline renders from. Re-exporting a reopened bundle reproduces its manifest exactly. It refuses to overwrite a PDF or project file already sitting there, because the obvious place to unpack is where someone's unfinished cuts live. Separately, every slice can now carry the measure it starts at, not just a re-engraved one — a scanned system is numbered in the score the same way, and noteman wants to answer "take it from bar 33" about either. It moves off the replacement onto the page, alongside markers and discards, and out of the bundle's engraving object onto the slice.
This commit is contained in:
Esa Kataja
+154
-2
@@ -69,7 +69,6 @@ def _engraving(project: Project, page: int, slot: int) -> dict | None:
|
||||
"key": replacement.key or project.key,
|
||||
"time": replacement.time or project.time,
|
||||
"print_time": replacement.print_time,
|
||||
**({"bar": replacement.bar} if replacement.bar else {}),
|
||||
"voices": [
|
||||
{"clef": v.clef, "notes": v.notes.strip()}
|
||||
| ({"lyrics": v.lyrics.strip()} if v.lyrics.strip() else {})
|
||||
@@ -78,6 +77,33 @@ def _engraving(project: Project, page: int, slot: int) -> dict | None:
|
||||
}
|
||||
|
||||
|
||||
def _source(project: Project) -> dict:
|
||||
"""How the slices were cut from the archived PDF.
|
||||
|
||||
Without this a bundle is a one-way trip: the images are output and the cuts
|
||||
that made them live only in the producer's own project file, so reopening
|
||||
someone else's bundle would mean cutting the score again from scratch. It
|
||||
is geometry in normalised page coordinates, so it survives the PDF being
|
||||
rendered at any resolution.
|
||||
|
||||
Only the pages are here. Which slot on which page a slice came from is on
|
||||
the slice itself, so that one ordering — the slices array — stays the only
|
||||
one, and a slot no slice claims is a slot that was discarded.
|
||||
"""
|
||||
return {
|
||||
"file": "original.pdf",
|
||||
"pages": [
|
||||
{
|
||||
"skew": round(page.skew, 2),
|
||||
"content": [round(v, 5) for v in project.page_content_rect(i)],
|
||||
"levels": list(project.page_levels(i)),
|
||||
"cuts": [[[round(x, 5), round(y, 5)] for x, y in cut.points] for cut in page.cuts],
|
||||
}
|
||||
for i, page in enumerate(project.pages)
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
def song_json(project: Project, files: list[str]) -> dict:
|
||||
payload: dict = {"v": FORMAT_VERSION}
|
||||
for field in METADATA_FIELDS:
|
||||
@@ -100,7 +126,10 @@ def song_json(project: Project, files: list[str]) -> dict:
|
||||
|
||||
slices: list[dict] = []
|
||||
for name, (page, slot) in zip(files, kept):
|
||||
entry: dict = {"file": name}
|
||||
entry: dict = {"file": name, "page": page, "slot": slot}
|
||||
bar = project.pages[page].bars[slot]
|
||||
if bar:
|
||||
entry["bar"] = bar
|
||||
engraving = _engraving(project, page, slot)
|
||||
if engraving:
|
||||
entry["engraving"] = engraving
|
||||
@@ -123,6 +152,8 @@ def song_json(project: Project, files: list[str]) -> dict:
|
||||
slices.append(entry)
|
||||
|
||||
payload["slices"] = slices
|
||||
if project.source.exists():
|
||||
payload["source"] = _source(project)
|
||||
return payload
|
||||
|
||||
|
||||
@@ -170,3 +201,124 @@ def write(project: Project, source: Source, path: Path) -> Path:
|
||||
project.exported = True
|
||||
project.save()
|
||||
return path
|
||||
|
||||
|
||||
def read(path: Path, into: Path | None = None, *, force: bool = False) -> tuple[Project, Path]:
|
||||
"""Unpack a bundle back into an editable project. Returns it and its PDF.
|
||||
|
||||
The archived PDF is written out beside the bundle and becomes the project's
|
||||
source again, because the PDF is what the pipeline renders from — the slice
|
||||
images in the zip are output, and are discarded rather than re-imported.
|
||||
|
||||
The cuts, skew, levels and content rectangles come from the manifest's
|
||||
`source` block, so this is a real round trip rather than a re-detection
|
||||
that happens to land nearby. A bundle written without one cannot give them
|
||||
back, and that is refused rather than guessed at.
|
||||
"""
|
||||
from .project import Cut, Marker, Page, Project, Replacement, Voice, default_path, hash_file
|
||||
|
||||
path = Path(path)
|
||||
with zipfile.ZipFile(path) as zf:
|
||||
names = set(zf.namelist())
|
||||
if "song.json" not in names:
|
||||
raise ValueError(f"{path.name} is not a bundle: no song.json")
|
||||
manifest = json.loads(zf.read("song.json"))
|
||||
if manifest.get("v") != FORMAT_VERSION:
|
||||
raise ValueError(f"unsupported bundle version {manifest.get('v')!r}")
|
||||
geometry = manifest.get("source")
|
||||
if not geometry:
|
||||
raise ValueError(
|
||||
f"{path.name} carries no cuts — it was written by a producer that "
|
||||
"does not record them, so the score would have to be cut again"
|
||||
)
|
||||
pdf_name = geometry.get("file", "original.pdf")
|
||||
if pdf_name not in names:
|
||||
raise ValueError(f"{path.name} names {pdf_name} but does not contain it")
|
||||
pdf_bytes = zf.read(pdf_name)
|
||||
|
||||
pages_json = geometry["pages"]
|
||||
slices = manifest["slices"]
|
||||
|
||||
# Every slot on a page exists; the ones no slice claims were discarded.
|
||||
# That is the one thing the bundle states by omission rather than directly,
|
||||
# since shipping a discarded slice's image would defeat discarding it.
|
||||
claimed = {(s["page"], s["slot"]): i for i, s in enumerate(slices)}
|
||||
pages = []
|
||||
for i, page in enumerate(pages_json):
|
||||
cuts = [Cut([tuple(p) for p in cut]) for cut in page["cuts"]]
|
||||
count = len(cuts) + 1
|
||||
pages.append(
|
||||
Page(
|
||||
skew=page.get("skew", 0.0),
|
||||
cuts=cuts,
|
||||
discards=[(i, slot) not in claimed for slot in range(count)],
|
||||
markers=[[] for _ in range(count)],
|
||||
replacements=[None] * count,
|
||||
bars=[None] * count,
|
||||
content_rect=tuple(page["content"]) if page.get("content") else None,
|
||||
levels=tuple(page["levels"]) if page.get("levels") else None,
|
||||
)
|
||||
)
|
||||
|
||||
position_of = {index: position for position, index in claimed.items()}
|
||||
for entry in slices:
|
||||
page, slot = entry["page"], entry["slot"]
|
||||
pages[page].bars[slot] = entry.get("bar")
|
||||
pages[page].markers[slot] = [
|
||||
Marker(
|
||||
type=marker["type"],
|
||||
label=marker.get("label"),
|
||||
# Back from an array index to the (page, slot) the editor works
|
||||
# in — the inverse of what export does.
|
||||
destination=position_of.get(marker.get("destination")),
|
||||
)
|
||||
for marker in entry.get("markers", [])
|
||||
]
|
||||
engraving = entry.get("engraving")
|
||||
if engraving and engraving.get("lang") == "lilypond":
|
||||
pages[page].replacements[slot] = Replacement(
|
||||
voices=[
|
||||
Voice(
|
||||
clef=v.get("clef", "treble"),
|
||||
notes=v.get("notes", ""),
|
||||
lyrics=v.get("lyrics", ""),
|
||||
)
|
||||
for v in engraving.get("voices", [])
|
||||
],
|
||||
print_time=engraving.get("print_time", False),
|
||||
)
|
||||
|
||||
# Unpacking writes two files. Refuse to land on either if it is already
|
||||
# there: the obvious place to open a bundle is next to the score it came
|
||||
# from, and that is exactly where someone's unfinished cuts live.
|
||||
target = Path(into) if into else path.with_suffix(".pdf")
|
||||
existing = [f for f in (target, default_path(target)) if f.exists()]
|
||||
if existing and not force:
|
||||
raise ValueError(
|
||||
f"{', '.join(f.name for f in existing)} already exists — "
|
||||
"open it with --pdf elsewhere, or --force to overwrite"
|
||||
)
|
||||
target.write_bytes(pdf_bytes)
|
||||
|
||||
metadata = {
|
||||
field: str(manifest[field]) for field in METADATA_FIELDS if manifest.get(field) is not None
|
||||
}
|
||||
first = pages_json[0] if pages_json else {}
|
||||
project = Project(
|
||||
source=target,
|
||||
source_hash=hash_file(target),
|
||||
pages=pages,
|
||||
content_rect=tuple(first.get("content", (0.0, 0.0, 1.0, 1.0))),
|
||||
levels=tuple(first.get("levels", (0, 255))),
|
||||
metadata=metadata,
|
||||
path=default_path(target),
|
||||
)
|
||||
# Key and time are per slice in the bundle and per song here; the first
|
||||
# engraving that states them is as good a song default as exists.
|
||||
for entry in slices:
|
||||
engraving = entry.get("engraving") or {}
|
||||
if engraving.get("key"):
|
||||
project.key = engraving["key"]
|
||||
project.time = engraving.get("time", project.time)
|
||||
break
|
||||
return project, target
|
||||
|
||||
Reference in New Issue
Block a user