Files
lintunes/lintunes/music_folder.py
T
trav 1b6014a50a v0.12.1: stop asking where the music is when config.json already says
Restarting on the machine that mounts the drive at /media/trav/muzak opened
"LinTunes can't find your music folder", offering ~/Music. The library's only
music_folder is the other machine's mount point (/run/media/trav/tummult/...)
because this library predates 0.10 and has no music_folder_rel yet — but
config.json has held the right path all along under music_root, which
`--music-root … --save-config` writes and the importer stores as
library.music_folder. resolve() only looked for music_folder_override, a key
that exists solely because the prompt writes it, so a library imported the
normal way could never satisfy the check that decides whether to prompt.

music_root is now a machine-local candidate alongside music_folder_override,
consulted in the same last-resort position and subject to the same must-exist
rule, so a stale one still reports "missing" rather than resolving to a phantom
tree. Read-only: nothing writes it back, and the newer key still wins when both
are present.

Claude-Session: https://claude.ai/code/session_01Y9ZEFi4qNJ39FMiBtiAxy2
2026-08-25 15:06:13 -04:00

155 lines
6.0 KiB
Python

"""Where the organized music tree lives, on *this* machine.
The library stores the music folder three ways (see `models/library.py`), and
which one applies depends on the machine you are sitting at. `resolve()` is the
single place that decides, in this order:
1. ``music_folder_rel`` resolved against the data dir — the portable value.
Both the music and the data dir ride one Syncthing share, so the *shape*
("the media folder is one level up from my data dir") is identical on every
machine even when the absolute paths are not.
2. ``music_folder`` — the legacy absolute value. Libraries written before 0.10,
and libraries last written by an older LinTunes, only have this one.
3. The machine-local override in ``~/.config/lintunes/config.json`` — either
``music_folder_override`` (set by the folder prompt) or the older
``music_root`` that ``--music-root … --save-config`` has always written.
The override is consulted **last, not first**, on purpose. If it won outright, a
machine that once needed an override would be pinned to it forever and would
never pick up a later shared change. Consulting it only after the shared value
fails to resolve gives an escape hatch *and* self-healing: plug the drive back
in and the shared setting takes over again on its own.
Every candidate must be an existing directory. A path that isn't there is not a
music folder — better to say "I can't find it" than to silently rebuild a
phantom tree next to wherever the app happened to be launched from.
"""
from dataclasses import dataclass
from pathlib import Path
from lintunes.config import load_config, save_config
from lintunes.paths import to_absolute
# Keys in the per-machine config.json (never synced).
OVERRIDE_KEY = "music_folder_override"
PROMPT_SEEN_KEY = "music_folder_prompted"
# The same fact under its pre-0.10 name: `--music-root … --save-config` has
# always written this machine's media folder here, and the importer stores it as
# `library.music_folder`. Every library set up that way therefore has the right
# answer sitting in config.json, and ignoring it meant a machine that mounts the
# drive somewhere else was asked to locate a folder it had already been told
# about. Read-only — nothing writes it back, so the newer key stays canonical.
LEGACY_OVERRIDE_KEY = "music_root"
@dataclass(frozen=True)
class Resolution:
"""What the music folder resolved to here, and where the answer came from."""
path: Path | None # an existing media folder, or None
source: str # library | legacy | machine | missing | unset
stored: str = "" # what we tried, for the "can't find it" copy
@property
def is_machine_local(self) -> bool:
return self.source == "machine"
def _existing_dir(candidate: str) -> Path | None:
if not candidate:
return None
path = Path(candidate).expanduser()
return path if path.is_dir() else None
def resolve(library, data_dir, config=None) -> Resolution:
"""Pick the media folder for this machine. See the module docstring."""
config = load_config() if config is None else config
stored = ""
rel = getattr(library, "music_folder_rel", "")
if rel:
stored = to_absolute(rel, str(data_dir))
found = _existing_dir(stored)
if found is not None:
return Resolution(found, "library", stored)
legacy = getattr(library, "music_folder", "")
if legacy:
stored = stored or legacy
found = _existing_dir(legacy)
if found is not None:
return Resolution(found, "legacy", legacy)
for key in (OVERRIDE_KEY, LEGACY_OVERRIDE_KEY):
override = config.get(key, "")
if not override:
continue
found = _existing_dir(override)
if found is not None:
return Resolution(found, "machine", override)
stored = stored or override
# Something is on file but not on this machine, versus never set at all —
# two different conversations to have with the user.
return Resolution(None, "missing" if stored else "unset", stored)
def normalize_media_folder(chosen) -> Path:
"""Turn the folder a user picked into the value we store.
``organize_root()`` is ``<media folder>/Music`` — the iTunes layout, where
an "iTunes Media" folder contains "Music". Taken literally, a newcomer who
picks ``~/Music`` would get ``~/Music/Music/Artist/Album``, which just looks
broken. So a folder that is *itself* called Music and doesn't already
contain one is treated as the tree, not its parent.
Applied once, at set time, so the answer is persisted and can never flip
later because a subfolder appeared. An "iTunes Media" folder (or any folder
that already has a Music child) is stored unchanged, which leaves existing
libraries exactly where they are.
"""
chosen = Path(chosen).expanduser()
if chosen.name.lower() == "music" and not (chosen / "Music").is_dir():
return chosen.parent
return chosen
def organize_root_for(media_folder) -> Path:
"""The tree files are actually filed into, for preview text."""
return Path(media_folder) / "Music"
def machine_override(config=None) -> str:
config = load_config() if config is None else config
return config.get(OVERRIDE_KEY, "")
def set_machine_override(path: str | None):
"""Record (or clear) this machine's own music folder. Never synced."""
config = load_config()
if path:
config[OVERRIDE_KEY] = str(path)
else:
config.pop(OVERRIDE_KEY, None)
save_config(config)
def prompt_seen(config=None) -> bool:
config = load_config() if config is None else config
return bool(config.get(PROMPT_SEEN_KEY))
def mark_prompt_seen():
"""Remember that this machine has been asked once.
Deliberately in config.json rather than preferences.json: preferences ride
the synced data dir, so a "Not Now" on one machine would silently suppress
the question on the other — but each machine may genuinely need its own
answer.
"""
config = load_config()
config[PROMPT_SEEN_KEY] = True
save_config(config)