python-musefs 0.0.1__tar.gz

python_musefs-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Conor Futro
+
+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.

python_musefs-0.0.1/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: python-musefs
+Version: 0.0.1
+Summary: Shared musefs SQLite-store contract for the beets and Picard plugins
+Author: Conor Futro
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Sohex/musefs
+Project-URL: Repository, https://github.com/Sohex/musefs
+Project-URL: Issues, https://github.com/Sohex/musefs/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# python-musefs
+
+The shared store-contract library behind the [beets](../beets/README.md),
+[Picard](../picard/README.md), and [Lidarr](../lidarr/README.md) musefs
+plugins. It is the single source of truth for how a plugin writes the musefs
+SQLite store: the schema-version check, the `tags` / `art` / `track_art`
+writes, sha256 art content-addressing, the `realpath_key` path normalization,
+the `musefs scan` shell-out (`run_scan`), and the per-file sync write-loop
+(`Record` / `sync_files`).
+
+Field mapping stays in each plugin — beets expands multi-valued
+`genres`/`composers` into one tag each, Picard takes the first value — so this
+library deliberately does not own it.
+
+## Consumers
+
+- **beets** depends on this package via pip (`contrib/beets/pyproject.toml`).
+- **Picard** cannot pip-install plugin dependencies, so the package is
+  **vendored** into `contrib/picard/musefs/_common/` by
+  `vendor_to_picard.py`. After any change here, re-run:
+
+  ```bash
+  python contrib/python-musefs/vendor_to_picard.py
+  ```
+
+  The Picard test `tests/test_vendor_sync.py` fails if the committed copy drifts.
+- **Lidarr** depends on this package via pip (`contrib/lidarr/pyproject.toml`).
+
+## Schema coupling
+
+`musefs_common/schema.py` (`SCHEMA_SQL`, `USER_VERSION`) is **generated** from
+the Rust migrations in `musefs-db/src/schema.rs` — do not edit it by hand.
+`EXPECTED_USER_VERSION` (in `constants.py`) derives from it. When the Rust
+schema bumps, regenerate and re-vendor:
+
+```bash
+MUSEFS_REGEN_SCHEMA_PY=1 cargo test -p musefs-db schema_py
+python contrib/python-musefs/vendor_to_picard.py
+```
+
+A `musefs-db` unit test fails if the generated file drifts. This is all
+independent of the package's own `__version__` (its release SemVer).
+
+## Tests
+
+```bash
+cd contrib/python-musefs
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[test]"
+python -m pytest -v
+ruff check . && ruff format --check .
+```

python_musefs-0.0.1/README.md

@@ -0,0 +1,52 @@
+# python-musefs
+
+The shared store-contract library behind the [beets](../beets/README.md),
+[Picard](../picard/README.md), and [Lidarr](../lidarr/README.md) musefs
+plugins. It is the single source of truth for how a plugin writes the musefs
+SQLite store: the schema-version check, the `tags` / `art` / `track_art`
+writes, sha256 art content-addressing, the `realpath_key` path normalization,
+the `musefs scan` shell-out (`run_scan`), and the per-file sync write-loop
+(`Record` / `sync_files`).
+
+Field mapping stays in each plugin — beets expands multi-valued
+`genres`/`composers` into one tag each, Picard takes the first value — so this
+library deliberately does not own it.
+
+## Consumers
+
+- **beets** depends on this package via pip (`contrib/beets/pyproject.toml`).
+- **Picard** cannot pip-install plugin dependencies, so the package is
+  **vendored** into `contrib/picard/musefs/_common/` by
+  `vendor_to_picard.py`. After any change here, re-run:
+
+  ```bash
+  python contrib/python-musefs/vendor_to_picard.py
+  ```
+
+  The Picard test `tests/test_vendor_sync.py` fails if the committed copy drifts.
+- **Lidarr** depends on this package via pip (`contrib/lidarr/pyproject.toml`).
+
+## Schema coupling
+
+`musefs_common/schema.py` (`SCHEMA_SQL`, `USER_VERSION`) is **generated** from
+the Rust migrations in `musefs-db/src/schema.rs` — do not edit it by hand.
+`EXPECTED_USER_VERSION` (in `constants.py`) derives from it. When the Rust
+schema bumps, regenerate and re-vendor:
+
+```bash
+MUSEFS_REGEN_SCHEMA_PY=1 cargo test -p musefs-db schema_py
+python contrib/python-musefs/vendor_to_picard.py
+```
+
+A `musefs-db` unit test fails if the generated file drifts. This is all
+independent of the package's own `__version__` (its release SemVer).
+
+## Tests
+
+```bash
+cd contrib/python-musefs
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[test]"
+python -m pytest -v
+ruff check . && ruff format --check .
+```

python_musefs-0.0.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "python-musefs"
+version = "0.0.1"
+description = "Shared musefs SQLite-store contract for the beets and Picard plugins"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Conor Futro" }]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: POSIX",
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Sound/Audio",
+]
+
+[project.urls]
+Homepage = "https://github.com/Sohex/musefs"
+Repository = "https://github.com/Sohex/musefs"
+Issues = "https://github.com/Sohex/musefs/issues"
+
+[project.optional-dependencies]
+test = ["pytest>=7"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+markers = [
+    "musefs_bin: tests that shell out to the real `musefs` Rust binary (opt-in)",
+]
+addopts = "-m 'not musefs_bin'"

python_musefs-0.0.1/setup.cfg

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

python_musefs-0.0.1/src/musefs_common/__init__.py

@@ -0,0 +1,49 @@
+"""python-musefs: the shared musefs SQLite-store contract.
+
+Single source of truth for the schema-version check, the tags/art/track_art
+writes, art content-addressing, path-key normalization, the `musefs scan`
+shell-out, and the per-file sync write-loop. Consumed by the beets plugin (as a
+pip dependency) and by the Picard plugin (vendored into ``musefs/_common``).
+"""
+
+from .constants import EXPECTED_USER_VERSION, MAX_ART_BYTES, SCAN_TIMEOUT_SECONDS
+from .errors import ScanError, SchemaMismatch
+from .paths import realpath_key
+from .scan import run_scan
+from .store import (
+    check_schema_version,
+    connect,
+    prune_missing,
+    replace_tags,
+    replace_track_art,
+    sniff_mime,
+    track_id_for_path,
+    upsert_art,
+)
+from .sync import ArtImage, Record, SyncStats, sync_files, sync_one
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "EXPECTED_USER_VERSION",
+    "MAX_ART_BYTES",
+    "SCAN_TIMEOUT_SECONDS",
+    "SchemaMismatch",
+    "ScanError",
+    "realpath_key",
+    "run_scan",
+    "connect",
+    "check_schema_version",
+    "track_id_for_path",
+    "prune_missing",
+    "replace_tags",
+    "upsert_art",
+    "replace_track_art",
+    "sniff_mime",
+    "ArtImage",
+    "Record",
+    "SyncStats",
+    "sync_one",
+    "sync_files",
+    "__version__",
+]

python_musefs-0.0.1/src/musefs_common/constants.py

@@ -0,0 +1,9 @@
+from .schema import USER_VERSION
+
+EXPECTED_USER_VERSION = USER_VERSION
+
+MAX_ART_BYTES = 16 * 1024 * 1024 - 64 * 1024
+
+# Wall-clock cap (seconds) for a single `musefs scan` shell-out; a wedged scan
+# (stuck disk, DB lock) raises ScanError(kind="timeout") rather than hanging.
+SCAN_TIMEOUT_SECONDS = 120

python_musefs-0.0.1/src/musefs_common/contract.py

@@ -0,0 +1,44 @@
+"""Canonical tag-row contract both plugins must satisfy.
+
+Each plugin's test builds an equivalent host object (a beets ``Item`` from the
+list fields, a Picard ``Metadata`` from ``getall``) carrying ``CONTRACT_VALUES``
+and asserts its ``map_fields`` output, normalized, equals
+``normalize_rows(CONTRACT_EXPECTED)``. This guards #84/#86 against future
+divergence between the two mappers.
+
+Scope: the genuinely-shared multi-value fields (``genre``, ``composer``). beets
+has no multi-artist field, so ``artist``/``albumartist`` are single-valued here;
+Picard's multi-artist expansion is tested in its own unit tests.
+"""
+
+from collections import defaultdict
+
+CONTRACT_VALUES = {
+    "title": "Song",
+    "artist": "Alice",
+    "albumartist": "Alice",
+    "album": "Greatest Hits",
+    "genre": ["Rock", "Pop"],
+    "composer": ["Carol", "Dave"],
+}
+
+CONTRACT_EXPECTED = [
+    ("title", "Song"),
+    ("artist", "Alice"),
+    ("albumartist", "Alice"),
+    ("album", "Greatest Hits"),
+    ("genre", "Rock"),
+    ("genre", "Pop"),
+    ("composer", "Carol"),
+    ("composer", "Dave"),
+]
+
+
+def normalize_rows(rows):
+    """Group ``(key, value)`` rows by key into a comparison-stable dict. All
+    contract keys use set semantics (the store treats multi-values as a set), so
+    each key's values are returned sorted."""
+    grouped = defaultdict(list)
+    for key, value in rows:
+        grouped[key].append(value)
+    return {key: sorted(values) for key, values in grouped.items()}

python_musefs-0.0.1/src/musefs_common/errors.py

@@ -0,0 +1,38 @@
+from .constants import EXPECTED_USER_VERSION
+
+
+class SchemaMismatch(Exception):  # noqa: N818
+    """Raised when the musefs DB schema version differs from what this library
+    targets (``EXPECTED_USER_VERSION``)."""
+
+    def __init__(self, found):
+        self.found = found
+        super().__init__(
+            f"musefs DB user_version is {found}, plugin targets "
+            f"{EXPECTED_USER_VERSION}; the musefs and plugin versions have "
+            f"diverged."
+        )
+
+
+class ScanError(Exception):  # noqa: N818
+    """A `musefs scan` invocation failed. ``kind`` is one of ``"not_found"``,
+    ``"timeout"``, ``"failed"``; the remaining attributes carry enough context
+    for a host adapter to format its own user-facing message."""
+
+    def __init__(self, kind, *, binary, target, timeout=None, returncode=None, stderr=""):
+        self.kind = kind
+        self.binary = binary
+        self.target = target
+        self.timeout = timeout
+        self.returncode = returncode
+        self.stderr = stderr
+        super().__init__(self._default_message())
+
+    def _default_message(self):
+        if self.kind == "not_found":
+            return f"musefs binary '{self.binary}' not found"
+        if self.kind == "timeout":
+            return f"`{self.binary} scan` for {self.target} timed out after {self.timeout}s"
+        return (
+            f"`{self.binary} scan` failed for {self.target} (exit {self.returncode}): {self.stderr}"
+        )

python_musefs-0.0.1/src/musefs_common/paths.py

@@ -0,0 +1,16 @@
+import os
+
+
+def realpath_key(path):
+    """Canonical absolute path string matching musefs scan's stored
+    ``backing_path`` (``std::fs::canonicalize`` + ``to_string_lossy``).
+
+    Accepts ``str`` or ``bytes`` and always returns ``str``.
+    """
+    real = os.path.realpath(path)
+    if isinstance(real, bytes):
+        real = os.fsdecode(real)
+    # os.fsdecode uses surrogateescape; Rust's to_string_lossy uses U+FFFD for
+    # undecodable bytes. Normalize so a non-UTF-8 path component produces the
+    # same key string on both sides instead of silently mismatching.
+    return real.encode("utf-8", "surrogateescape").decode("utf-8", "replace")

python_musefs-0.0.1/src/musefs_common/scan.py

@@ -0,0 +1,33 @@
+import os
+import subprocess
+
+from .errors import ScanError
+
+
+def run_scan(binary, db_path, target, *, timeout=None):
+    """Run ``<binary> scan <target...> --db <db_path>``. ``target`` is a single
+    path or an iterable of paths; all targets precede the ``--db`` flag and are
+    scanned under one process (one DB open). Creates the DB if absent and fills
+    the structural columns a plugin can't compute. Raises ``ScanError`` (with
+    ``kind`` in ``"not_found" | "timeout" | "failed"``) on failure; the caller
+    formats its own user-facing message from the exception attributes."""
+    if isinstance(target, (str, os.PathLike)):
+        targets = [target]
+    else:
+        targets = list(target)
+    display = str(targets[0]) if len(targets) == 1 else f"{len(targets)} target(s)"
+    argv = [binary, "scan", *(str(t) for t in targets), "--db", str(db_path)]
+    try:
+        result = subprocess.run(argv, capture_output=True, timeout=timeout)
+    except FileNotFoundError as exc:
+        raise ScanError("not_found", binary=binary, target=display) from exc
+    except subprocess.TimeoutExpired as exc:
+        raise ScanError("timeout", binary=binary, target=display, timeout=timeout) from exc
+    if result.returncode != 0:
+        raise ScanError(
+            "failed",
+            binary=binary,
+            target=display,
+            returncode=result.returncode,
+            stderr=result.stderr.decode(errors="replace").strip(),
+        )

python_musefs-0.0.1/src/musefs_common/schema.py

@@ -0,0 +1,243 @@
+# GENERATED from musefs-db/src/schema.rs — do not edit.
+# Regenerate: MUSEFS_REGEN_SCHEMA_PY=1 cargo test -p musefs-db schema_py
+# Re-vendor:  python contrib/python-musefs/vendor_to_picard.py
+
+SCHEMA_SQL = """\
+-- ── MIGRATION_V1 ──
+CREATE TABLE tracks (
+    id              INTEGER PRIMARY KEY,
+    backing_path    TEXT NOT NULL UNIQUE,
+    format          TEXT NOT NULL,
+    audio_offset    INTEGER NOT NULL,
+    audio_length    INTEGER NOT NULL,
+    backing_size    INTEGER NOT NULL,
+    backing_mtime   INTEGER NOT NULL,
+    content_version INTEGER NOT NULL DEFAULT 0,
+    updated_at      INTEGER NOT NULL
+);
+
+CREATE TABLE tags (
+    track_id INTEGER NOT NULL REFERENCES tracks(id) ON DELETE CASCADE,
+    key      TEXT NOT NULL,
+    value    TEXT NOT NULL,
+    ordinal  INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (track_id, key, ordinal)
+);
+
+CREATE TABLE art (
+    id       INTEGER PRIMARY KEY,
+    sha256   TEXT NOT NULL UNIQUE,
+    mime     TEXT NOT NULL,
+    width    INTEGER,
+    height   INTEGER,
+    byte_len INTEGER NOT NULL,
+    data     BLOB NOT NULL
+);
+
+CREATE TABLE track_art (
+    track_id     INTEGER NOT NULL REFERENCES tracks(id) ON DELETE CASCADE,
+    art_id       INTEGER NOT NULL REFERENCES art(id),
+    picture_type INTEGER NOT NULL DEFAULT 3,
+    description  TEXT NOT NULL DEFAULT '',
+    ordinal      INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (track_id, ordinal)
+);
+
+CREATE TRIGGER tags_ai AFTER INSERT ON tags BEGIN
+    UPDATE tracks SET content_version = content_version + 1,
+                      updated_at = CAST(strftime('%s','now') AS INTEGER)
+    WHERE id = NEW.track_id;
+END;
+CREATE TRIGGER tags_au AFTER UPDATE ON tags BEGIN
+    UPDATE tracks SET content_version = content_version + 1,
+                      updated_at = CAST(strftime('%s','now') AS INTEGER)
+    WHERE id = NEW.track_id;
+END;
+CREATE TRIGGER tags_ad AFTER DELETE ON tags BEGIN
+    UPDATE tracks SET content_version = content_version + 1,
+                      updated_at = CAST(strftime('%s','now') AS INTEGER)
+    WHERE id = OLD.track_id;
+END;
+
+CREATE TRIGGER track_art_ai AFTER INSERT ON track_art BEGIN
+    UPDATE tracks SET content_version = content_version + 1,
+                      updated_at = CAST(strftime('%s','now') AS INTEGER)
+    WHERE id = NEW.track_id;
+END;
+CREATE TRIGGER track_art_au AFTER UPDATE ON track_art BEGIN
+    UPDATE tracks SET content_version = content_version + 1,
+                      updated_at = CAST(strftime('%s','now') AS INTEGER)
+    WHERE id = NEW.track_id;
+END;
+CREATE TRIGGER track_art_ad AFTER DELETE ON track_art BEGIN
+    UPDATE tracks SET content_version = content_version + 1,
+                      updated_at = CAST(strftime('%s','now') AS INTEGER)
+    WHERE id = OLD.track_id;
+END;
+PRAGMA user_version = 1;
+
+-- ── MIGRATION_V2 ──
+-- Binary tag payloads live alongside text tags. A row is binary iff
+-- value_blob IS NOT NULL; binary rows store '' in value.
+ALTER TABLE tags ADD COLUMN value_blob BLOB;
+
+-- Read-only, derived-from-file structural metadata (FLAC STREAMINFO/SEEKTABLE).
+-- NOT part of the editable `tags` contract: external tools never touch it.
+CREATE TABLE structural_blocks (
+    track_id INTEGER NOT NULL REFERENCES tracks(id) ON DELETE CASCADE,
+    kind     TEXT NOT NULL,
+    ordinal  INTEGER NOT NULL DEFAULT 0,
+    body     BLOB NOT NULL,
+    PRIMARY KEY (track_id, kind, ordinal)
+);
+PRAGMA user_version = 2;
+
+-- ── MIGRATION_V3 ──
+-- Bounded changelog ring for O(changed) refresh. Every metadata edit funnels
+-- through an UPDATE on the tracks row (the V1 tags/track_art triggers), so
+-- triggers on tracks alone capture all writers. Relies on SQLite nested
+-- trigger activation (on by default; distinct from PRAGMA recursive_triggers).
+CREATE TABLE track_changes (
+    seq      INTEGER PRIMARY KEY AUTOINCREMENT,
+    track_id INTEGER NOT NULL
+);
+
+CREATE TRIGGER tracks_changelog_ai AFTER INSERT ON tracks BEGIN
+    INSERT INTO track_changes (track_id) VALUES (NEW.id);
+END;
+CREATE TRIGGER tracks_changelog_au AFTER UPDATE ON tracks BEGIN
+    INSERT INTO track_changes (track_id) VALUES (NEW.id);
+END;
+CREATE TRIGGER tracks_changelog_ad AFTER DELETE ON tracks BEGIN
+    INSERT INTO track_changes (track_id) VALUES (OLD.id);
+END;
+
+-- Self-pruning ring: writers maintain it; the mount's read-only connections
+-- never need to. Deletes only from the old end, so retained seqs stay contiguous.
+CREATE TRIGGER track_changes_prune AFTER INSERT ON track_changes BEGIN
+    DELETE FROM track_changes WHERE seq <= NEW.seq - 8192;
+END;
+PRAGMA user_version = 3;
+
+-- ── MIGRATION_V4 ──
+CREATE TEMP TABLE _m4_tracks AS SELECT * FROM tracks;
+CREATE TEMP TABLE _m4_tags AS SELECT * FROM tags;
+CREATE TEMP TABLE _m4_art AS SELECT * FROM art;
+CREATE TEMP TABLE _m4_track_art AS SELECT * FROM track_art;
+
+DROP TABLE track_art;
+DROP TABLE tags;
+DROP TABLE art;
+DROP TABLE tracks;
+
+CREATE TABLE tracks (
+    id              INTEGER PRIMARY KEY,
+    backing_path    TEXT NOT NULL UNIQUE,
+    format          TEXT NOT NULL,
+    audio_offset    INTEGER NOT NULL,
+    audio_length    INTEGER NOT NULL,
+    backing_size    INTEGER NOT NULL,
+    backing_mtime   INTEGER NOT NULL,
+    content_version INTEGER NOT NULL DEFAULT 0,
+    updated_at      INTEGER NOT NULL,
+    CHECK (format IN ('flac','mp3','m4a','opus','vorbis','oggflac','wav')),
+    CHECK (audio_offset >= 0),
+    CHECK (audio_length >= 0),
+    CHECK (backing_size >= 0),
+    CHECK (backing_mtime >= 0),
+    CHECK (content_version >= 0),
+    CHECK (updated_at >= 0),
+    CHECK (audio_offset + audio_length <= backing_size)
+);
+
+CREATE TABLE tags (
+    track_id   INTEGER NOT NULL REFERENCES tracks(id) ON DELETE CASCADE,
+    key        TEXT NOT NULL,
+    value      TEXT NOT NULL,
+    ordinal    INTEGER NOT NULL DEFAULT 0,
+    value_blob BLOB,
+    PRIMARY KEY (track_id, key, ordinal),
+    CHECK (ordinal >= 0),
+    CHECK (value_blob IS NULL OR value = '')
+);
+
+CREATE TABLE art (
+    id       INTEGER PRIMARY KEY,
+    sha256   TEXT NOT NULL UNIQUE,
+    mime     TEXT NOT NULL,
+    width    INTEGER,
+    height   INTEGER,
+    byte_len INTEGER NOT NULL,
+    data     BLOB NOT NULL,
+    CHECK (byte_len = length(data)),
+    CHECK (length(sha256) = 64),
+    CHECK (width IS NULL OR width >= 0),
+    CHECK (height IS NULL OR height >= 0)
+);
+
+CREATE TABLE track_art (
+    track_id     INTEGER NOT NULL REFERENCES tracks(id) ON DELETE CASCADE,
+    art_id       INTEGER NOT NULL REFERENCES art(id),
+    picture_type INTEGER NOT NULL DEFAULT 3,
+    description  TEXT NOT NULL DEFAULT '',
+    ordinal      INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (track_id, ordinal),
+    CHECK (picture_type BETWEEN 0 AND 20),
+    CHECK (ordinal >= 0)
+);
+
+INSERT INTO tracks SELECT * FROM _m4_tracks;
+INSERT INTO art SELECT * FROM _m4_art;
+INSERT INTO tags SELECT * FROM _m4_tags;
+INSERT INTO track_art SELECT * FROM _m4_track_art;
+
+DROP TABLE _m4_track_art;
+DROP TABLE _m4_tags;
+DROP TABLE _m4_art;
+DROP TABLE _m4_tracks;
+
+CREATE TRIGGER tags_ai AFTER INSERT ON tags BEGIN
+    UPDATE tracks SET content_version = content_version + 1,
+                      updated_at = CAST(strftime('%s','now') AS INTEGER)
+    WHERE id = NEW.track_id;
+END;
+CREATE TRIGGER tags_au AFTER UPDATE ON tags BEGIN
+    UPDATE tracks SET content_version = content_version + 1,
+                      updated_at = CAST(strftime('%s','now') AS INTEGER)
+    WHERE id = NEW.track_id;
+END;
+CREATE TRIGGER tags_ad AFTER DELETE ON tags BEGIN
+    UPDATE tracks SET content_version = content_version + 1,
+                      updated_at = CAST(strftime('%s','now') AS INTEGER)
+    WHERE id = OLD.track_id;
+END;
+
+CREATE TRIGGER track_art_ai AFTER INSERT ON track_art BEGIN
+    UPDATE tracks SET content_version = content_version + 1,
+                      updated_at = CAST(strftime('%s','now') AS INTEGER)
+    WHERE id = NEW.track_id;
+END;
+CREATE TRIGGER track_art_au AFTER UPDATE ON track_art BEGIN
+    UPDATE tracks SET content_version = content_version + 1,
+                      updated_at = CAST(strftime('%s','now') AS INTEGER)
+    WHERE id = NEW.track_id;
+END;
+CREATE TRIGGER track_art_ad AFTER DELETE ON track_art BEGIN
+    UPDATE tracks SET content_version = content_version + 1,
+                      updated_at = CAST(strftime('%s','now') AS INTEGER)
+    WHERE id = OLD.track_id;
+END;
+
+CREATE TRIGGER tracks_changelog_ai AFTER INSERT ON tracks BEGIN
+    INSERT INTO track_changes (track_id) VALUES (NEW.id);
+END;
+CREATE TRIGGER tracks_changelog_au AFTER UPDATE ON tracks BEGIN
+    INSERT INTO track_changes (track_id) VALUES (NEW.id);
+END;
+CREATE TRIGGER tracks_changelog_ad AFTER DELETE ON tracks BEGIN
+    INSERT INTO track_changes (track_id) VALUES (OLD.id);
+END;
+PRAGMA user_version = 4;
+"""
+
+USER_VERSION = 4