Active_prgs/Gromulus/Gromulus_Lib.py

"""Core data access methods for Gromulus."""

import configparser
import os
import shutil
import sqlite3
import xml.etree.ElementTree as ET

import Tool_Box.NinoGenTools


config = configparser.ConfigParser()
config.read("/home/nino/.gromulus/gromulus_cfg.ini")

#conn = sqlite3.connect(config.get('RootConfig','databasePath'))


class DatabaseManager:
    def __init__(self):
        self.db_path = config.get('RootConfig','databasePath')  # Hardcoded DB path
        self.conn = sqlite3.connect(self.db_path)

    def get_connection(self):
        return self.conn

    def close(self):
        if self.conn:
            self.conn.close()
            self.conn = None


def _column_exists(conn, table_name, column_name):
    columns = [row[1] for row in conn.execute(f"PRAGMA table_info({table_name})")]
    return column_name in columns


def EnsureMetadataSchema(conn):
    """Adds metadata-scoped columns/tables required by current import and matching workflow."""
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS dat_import_history(
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            app_system_id INTEGER NOT NULL,
            source TEXT NOT NULL,
            dat_name TEXT,
            dat_description TEXT,
            dat_version TEXT,
            imported_at TEXT NOT NULL,
            entry_count INTEGER NOT NULL DEFAULT 0,
            UNIQUE(app_system_id, source),
            FOREIGN KEY(app_system_id) REFERENCES main_app_system(id)
        )
        """
    )

    if not _column_exists(conn, "no_intro_main", "app_system_id"):
        conn.execute("ALTER TABLE no_intro_main ADD COLUMN app_system_id INTEGER")
    if not _column_exists(conn, "tosec_main", "app_system_id"):
        conn.execute("ALTER TABLE tosec_main ADD COLUMN app_system_id INTEGER")
    if not _column_exists(conn, "main_app", "favorite_game"):
        conn.execute("ALTER TABLE main_app ADD COLUMN favorite_game INTEGER")
    if not _column_exists(conn, "main_app", "release_date"):
        conn.execute("ALTER TABLE main_app ADD COLUMN release_date TEXT")
    if not _column_exists(conn, "main_app", "release_date_scraped"):
        conn.execute("ALTER TABLE main_app ADD COLUMN release_date_scraped TEXT")
    if not _column_exists(conn, "main_app", "game_genre"):
        conn.execute("ALTER TABLE main_app ADD COLUMN game_genre TEXT")
    if not _column_exists(conn, "main_app", "game_genre_scraped"):
        conn.execute("ALTER TABLE main_app ADD COLUMN game_genre_scraped TEXT")
    if not _column_exists(conn, "main_app", "cooperative"):
        conn.execute("ALTER TABLE main_app ADD COLUMN cooperative TEXT")
    if not _column_exists(conn, "main_app", "cooperative_scraped"):
        conn.execute("ALTER TABLE main_app ADD COLUMN cooperative_scraped TEXT")
    if not _column_exists(conn, "main_app", "max_players"):
        conn.execute("ALTER TABLE main_app ADD COLUMN max_players TEXT")
    if not _column_exists(conn, "main_app", "max_players_scraped"):
        conn.execute("ALTER TABLE main_app ADD COLUMN max_players_scraped TEXT")

    # Backfill app_system_id from matched file hashes where possible.
    conn.execute(
        """
        UPDATE no_intro_main
        SET app_system_id = (
            SELECT ma.system_console
            FROM main_app_file_hash fh
            JOIN main_app ma ON ma.id = fh.container_file_id
            WHERE lower(fh.file_md5_hash) = lower(no_intro_main.md5)
            GROUP BY ma.system_console
            ORDER BY COUNT(*) DESC
            LIMIT 1
        )
        WHERE app_system_id IS NULL
        """
    )
    conn.execute(
        """
        UPDATE tosec_main
        SET app_system_id = (
            SELECT ma.system_console
            FROM main_app_file_hash fh
            JOIN main_app ma ON ma.id = fh.container_file_id
            WHERE lower(fh.file_md5_hash) = lower(tosec_main.md5)
            GROUP BY ma.system_console
            ORDER BY COUNT(*) DESC
            LIMIT 1
        )
        WHERE app_system_id IS NULL
        """
    )

    conn.execute("CREATE INDEX IF NOT EXISTS idx_no_intro_system_md5 ON no_intro_main(app_system_id, md5)")
    conn.execute("CREATE INDEX IF NOT EXISTS idx_tosec_system_md5 ON tosec_main(app_system_id, md5)")
    conn.execute("CREATE INDEX IF NOT EXISTS idx_dat_import_system_source ON dat_import_history(app_system_id, source)")
    conn.commit()


def _record_dat_import(conn, app_system_id, source, dat_name, dat_description, dat_version, entry_count):
    conn.execute(
        """
        INSERT INTO dat_import_history(
            app_system_id, source, dat_name, dat_description, dat_version, imported_at, entry_count
        ) VALUES (?, ?, ?, ?, ?, datetime('now'), ?)
        ON CONFLICT(app_system_id, source) DO UPDATE SET
            dat_name=excluded.dat_name,
            dat_description=excluded.dat_description,
            dat_version=excluded.dat_version,
            imported_at=excluded.imported_at,
            entry_count=excluded.entry_count
        """,
        (app_system_id, source, dat_name, dat_description, dat_version, entry_count),
    )


def ImportNewNoIntroDat(datPath, app_system_id, conn):
    """Replace No-Intro data using a DAT file."""
    EnsureMetadataSchema(conn)
    tree = ET.parse(datPath)
    root = tree.getroot()
    cursor = conn.cursor()

    header = root.find("header")
    if header is None:
        raise ValueError("Invalid DAT file: missing <header> section.")

    headerID = header.findtext("id") or ""
    headerName = header.findtext("name") or ""
    headerDesc = header.findtext("description") or ""
    headerVer = header.findtext("version") or ""

    cursor.execute("DELETE FROM no_intro_main WHERE app_system_id = ?", (app_system_id,))
    insert_sql = """
        INSERT INTO no_intro_main(
            game_name, no_intro_id, clone_of_id, description, rom_name,
            crc, md5, sha1, sha256, status, no_intro_system_id, app_system_id
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    """
    imported_count = 0
    for elm in root.findall("game"):
        gameName = elm.get("name")
        gameID = elm.get("id") or ""
        gameCloneOfID = elm.get("cloneofid")
        gameDesc = elm.findtext("description")

        rom = elm.find("rom")
        if rom is None:
            continue
        romName = rom.get("name")
        romCRC = rom.get("crc")
        romMD5 = rom.get("md5")
        romSHA1 = rom.get("sha1")
        romSHA256 = rom.get("sha256")
        romStatus = rom.get("status")

        cursor.execute(
            insert_sql,
            (
                gameName,
                gameID,
                gameCloneOfID,
                gameDesc,
                romName,
                romCRC,
                romMD5,
                romSHA1,
                romSHA256,
                romStatus,
                int(headerID) if headerID.isdigit() else 0,
                app_system_id,
            ),
        )
        imported_count += 1

    _record_dat_import(
        conn,
        app_system_id,
        "no_intro",
        headerName,
        headerDesc,
        headerVer,
        imported_count,
    )

    conn.commit()


def ImportNewTosecDat(datPath, app_system_id, conn):
    """Replace TOSEC data using a DAT file."""
    EnsureMetadataSchema(conn)
    cursor = conn.cursor()
    tree = ET.parse(datPath)
    root = tree.getroot()

    header = root.find("header")
    if header is None:
        raise ValueError("Invalid DAT file: missing <header> section.")
    system_name = header.findtext("name") or ""
    system_desc = header.findtext("description") or ""
    version = header.findtext("version") or ""

    cursor.execute("DELETE FROM tosec_main WHERE app_system_id = ?", (app_system_id,))
    insert_sql = """
        INSERT INTO tosec_main(game_name, description, rom_name, crc, md5, sha1, system_id, app_system_id)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
    """
    imported_count = 0
    for game in root.findall("game"):
        game_name = game.attrib.get("name", "")
        game_desc = game.findtext("description")
        rom = game.find("rom")
        if rom is None:
            continue
        cursor.execute(
            insert_sql,
            (
                game_name,
                game_desc,
                rom.attrib.get("name", ""),
                rom.attrib.get("crc", ""),
                rom.attrib.get("md5", ""),
                rom.attrib.get("sha1", ""),
                app_system_id,
                app_system_id,
            ),
        )
        imported_count += 1

    _record_dat_import(
        conn,
        app_system_id,
        "tosec",
        system_name,
        system_desc,
        version,
        imported_count,
    )

    conn.commit()
    print("TOSEC DAT imported successfully.")


def AddNewSystem(systemName, shortName, relativePath, conn):
    """Adding a single system, with path where the ROMs will live."""
    conn.execute(
        'INSERT INTO main_app_system("name", "short_name", "relative_file_path") VALUES (?, ?, ?)',
        (systemName, shortName, relativePath),
    )
    conn.commit()


def AddNewRoms(pathToRoms, systemID, conn, testOnly = False):
    """Adding additional roms."""
    importedCount = 0
    alreadyExistsCount = 0
    errImportCount = 0

    system_row = conn.execute(
        "SELECT relative_file_path FROM main_app_system WHERE id = ?",
        (systemID,),
    ).fetchone()
    if not system_row:
        raise ValueError(f"System id {systemID} not found in main_app_system.")

    systemRomPath = system_row[0]
    fullRomPath = os.path.join(config.get("RootConfig", "softwareBackupStartDir"), systemRomPath)
    os.makedirs(fullRomPath, exist_ok=True)

    currentHashList = {
        row[0]
        for row in conn.execute("SELECT container_md5_hash FROM main_app WHERE container_md5_hash IS NOT NULL")
    }
    print(len(currentHashList))

    hshr = Tool_Box.NinoGenTools.HashFileContents("md5")
    for testFile in os.listdir(pathToRoms):
        source_path = os.path.join(pathToRoms, testFile)
        if not os.path.isfile(source_path):
            continue

        print(f"\n\nNow analyzing {testFile}...")
        hashVal = hshr.HashFile(source_path)
        if hashVal in currentHashList:
            print("This file is already in your collection, skipping.")
            alreadyExistsCount +=1
        else:
            print("This file is unique.  Adding to collection.")
            fileNameInc = 0
            targetFileName = testFile
            while os.path.isfile(os.path.join(fullRomPath,targetFileName)):
                fileNameInc +=1
                testFileNamePart, testFileExt = os.path.splitext(testFile)
                targetFileName = testFileNamePart +"_"+ str(fileNameInc) + testFileExt
            if testOnly:
                pass
            else:
                try:
                    shutil.copyfile(source_path, os.path.join(fullRomPath, targetFileName))
                    conn.execute(
                        'INSERT INTO main_app("container_file_name", "system_console", "container_md5_hash") VALUES(?, ?, ?)',
                        (targetFileName, systemID, hashVal),
                    )
                    conn.commit()
                except Exception:
                    errImportCount += 1
                    continue
            currentHashList.add(hashVal)
            importedCount +=1
    return importedCount, alreadyExistsCount, errImportCount


def _normalize_match_key(name):
    if not name:
        return ""
    normalized = name.lower().strip()
    # Normalize common filename separators to improve filename/title matching.
    for ch in ("_", "-", ".", ",", "!", ":", ";", "'", '"', "(", ")", "[", "]"):
        normalized = normalized.replace(ch, " ")
    return " ".join(normalized.split())


def GetSystemListWithRoms(conn):
    res = conn.execute(
        """
        SELECT s.id, s.name, s.short_name, s.relative_file_path
        FROM main_app_system s
        WHERE EXISTS (
            SELECT 1 FROM main_app ma WHERE ma.system_console = s.id
        )
        ORDER BY s.name
        """
    )
    systemNamesMatrix = {}
    for h in res:
        systemNamesMatrix[h[1]] = [h[0], h[2], h[3]]
    return systemNamesMatrix


def AddNewArtwork(pathToArtwork, systemID, artworkType, conn, testOnly=False):
    """
    Ingest artwork for a system by matching names in this order:
    game_name -> no_intro_game_name -> tosec_game_name -> filename stem.
    Only updates rows where the target artwork field is empty.
    """
    artwork_field_map = {
        "box": "path_to_screenshot_box",
        "title": "path_to_screenshot_title",
        "ingame": "path_to_screenshot_ingame",
    }
    if artworkType not in artwork_field_map:
        raise ValueError(f"Unsupported artwork type: {artworkType}")

    target_field = artwork_field_map[artworkType]
    system_row = conn.execute(
        "SELECT short_name FROM main_app_system WHERE id = ?",
        (systemID,),
    ).fetchone()
    if not system_row:
        raise ValueError(f"System id {systemID} not found.")
    system_short_name = system_row[0]

    artwork_root = config.get("RootConfig", "softwareArtworkDir")
    target_dir = os.path.join(artwork_root, system_short_name)
    os.makedirs(target_dir, exist_ok=True)

    source_file_map = {}
    for entry in os.listdir(pathToArtwork):
        full_path = os.path.join(pathToArtwork, entry)
        if not os.path.isfile(full_path):
            continue
        stem, _ext = os.path.splitext(entry)
        key = _normalize_match_key(stem)
        if key and key not in source_file_map:
            source_file_map[key] = full_path

    no_intro_scoped = _column_exists(conn, "no_intro_main", "app_system_id")
    tosec_scoped = _column_exists(conn, "tosec_main", "app_system_id")
    no_intro_join = (
        "LEFT JOIN no_intro_main nim ON lower(fh.file_md5_hash)=lower(nim.md5) AND nim.app_system_id=ma.system_console"
        if no_intro_scoped
        else "LEFT JOIN no_intro_main nim ON lower(fh.file_md5_hash)=lower(nim.md5)"
    )
    tosec_join = (
        "LEFT JOIN tosec_main tm ON lower(fh.file_md5_hash)=lower(tm.md5) AND tm.app_system_id=ma.system_console"
        if tosec_scoped
        else "LEFT JOIN tosec_main tm ON lower(fh.file_md5_hash)=lower(tm.md5)"
    )

    rows = conn.execute(
        f"""
        SELECT ma.id,
               ma.game_name,
               nim.game_name,
               tm.game_name,
               COALESCE(fh.file_name, ma.container_file_name) AS best_filename,
               ma.{target_field}
        FROM main_app ma
        LEFT JOIN main_app_file_hash fh
            ON fh.id = (
                SELECT MIN(fh2.id)
                FROM main_app_file_hash fh2
                WHERE fh2.container_file_id = ma.id
            )
        {no_intro_join}
        {tosec_join}
        WHERE ma.system_console = ?
        """,
        (systemID,),
    )

    matched_count = 0
    skipped_existing_count = 0
    unmatched_count = 0
    error_count = 0

    for game_id, game_name, no_intro_name, tosec_name, best_filename, existing_path in rows:
        if existing_path:
            skipped_existing_count += 1
            continue

        filename_stem = os.path.splitext(best_filename)[0] if best_filename else ""
        candidate_names = [game_name, no_intro_name, tosec_name, filename_stem]

        source_match = None
        for candidate in candidate_names:
            key = _normalize_match_key(candidate)
            if key and key in source_file_map:
                source_match = source_file_map[key]
                break

        if not source_match:
            unmatched_count += 1
            continue

        source_name = os.path.basename(source_match)
        source_stem, source_ext = os.path.splitext(source_name)
        target_name = f"{artworkType}_{source_stem}{source_ext}"
        target_path = os.path.join(target_dir, target_name)

        increment = 1
        while os.path.exists(target_path):
            target_name = f"{artworkType}_{source_stem}_{increment}{source_ext}"
            target_path = os.path.join(target_dir, target_name)
            increment += 1

        relative_path = os.path.relpath(target_path, artwork_root)
        if testOnly:
            matched_count += 1
            continue

        try:
            shutil.copyfile(source_match, target_path)
            conn.execute(
                f"UPDATE main_app SET {target_field} = ? WHERE id = ?",
                (relative_path, game_id),
            )
            matched_count += 1
        except Exception:
            error_count += 1

    if not testOnly:
        conn.commit()

    return matched_count, skipped_existing_count, unmatched_count, error_count


def GetSystemList(conn):
    res = conn.execute("SELECT id, name, short_name, relative_file_path FROM main_app_system ")
    systemNamesMatrix = {}
    for h in res:
        systemNamesMatrix[h[1]] = [h[0],h[2],h[3]]
    return systemNamesMatrix

def GetGameListBySystem(systemName, conn):
    system_row = conn.execute(
        """
        SELECT id
        FROM main_app_system
        WHERE lower(short_name) = lower(?)
           OR lower(name) = lower(?)
        """,
        (systemName, systemName),
    ).fetchone()
    if not system_row:
        return {}

    system_id = system_row[0]
    no_intro_scoped = _column_exists(conn, "no_intro_main", "app_system_id")
    tosec_scoped = _column_exists(conn, "tosec_main", "app_system_id")

    no_intro_join = (
        "LEFT JOIN no_intro_main nim ON lower(fh.file_md5_hash) = lower(nim.md5) "
        "AND nim.app_system_id = ma.system_console"
        if no_intro_scoped
        else "LEFT JOIN no_intro_main nim ON lower(fh.file_md5_hash) = lower(nim.md5)"
    )
    tosec_join = (
        "LEFT JOIN tosec_main tm ON lower(fh.file_md5_hash) = lower(tm.md5) "
        "AND tm.app_system_id = ma.system_console"
        if tosec_scoped
        else "LEFT JOIN tosec_main tm ON lower(fh.file_md5_hash) = lower(tm.md5)"
    )

    res = conn.execute(
        f"""
        SELECT ma.id,
               ma.game_name,
               nim.game_name,
               tm.game_name,
               COALESCE(fh.file_name, ma.container_file_name)
        FROM main_app ma
        LEFT JOIN main_app_file_hash fh
            ON fh.id = (
                SELECT MIN(fh2.id)
                FROM main_app_file_hash fh2
                WHERE fh2.container_file_id = ma.id
            )
        {no_intro_join}
        {tosec_join}
        WHERE ma.system_console = ?
        """,
        (system_id,),
    )
    gameNamesMatrix = {}
    duplicate_counter = {}
    for h in res:
        if h[1]:
            display_name = h[1]
        elif h[2]:
            display_name = h[2]
        elif h[3]:
            display_name = h[3]
        else:
            display_name = h[4] or f"Unknown-{h[0]}"

        # Keep titles unique in the listbox mapping.
        if display_name in gameNamesMatrix:
            duplicate_counter[display_name] = duplicate_counter.get(display_name, 1) + 1
            unique_name = f"{display_name} ({duplicate_counter[display_name]})"
            gameNamesMatrix[unique_name] = h[0]
        else:
            duplicate_counter[display_name] = 1
            gameNamesMatrix[display_name] = h[0]

    return gameNamesMatrix


def GetSingleGameById(game_id, conn):
    """Fetches full metadata for a single ROM entry, including No-Intro and TOSEC info if available."""
    cursor = conn.cursor()

    cursor.execute("""
        SELECT ma.id,
               ma.game_name,
               ma.container_file_name,
               sys.name,
               sys.short_name,
               sys.relative_file_path,
               ma.container_md5_hash,
               ma.system_console,
               ma.path_to_screenshot_box,
               ma.path_to_screenshot_title,
               ma.path_to_screenshot_ingame,
               ma.favorite_game,
               ma.release_date,
               ma.release_date_scraped,
               ma.game_genre,
               ma.game_genre_scraped,
               ma.cooperative,
               ma.cooperative_scraped,
               ma.max_players,
               ma.max_players_scraped,
               ma.description,
               ma.description_scraped,
               ma.user_notes
        FROM main_app ma
        LEFT JOIN main_app_system sys ON ma.system_console = sys.id
        WHERE ma.id = ?
    """, (game_id,))
    game = cursor.fetchone()
    if not game:
        return None

    file_hash_row = cursor.execute(
        """
        SELECT file_name, file_md5_hash
        FROM main_app_file_hash
        WHERE container_file_id = ?
        ORDER BY id ASC
        LIMIT 1
        """,
        (game[0],),
    ).fetchone()

    resolved_file_name = file_hash_row[0] if file_hash_row and file_hash_row[0] else game[2]
    resolved_hash = file_hash_row[1] if file_hash_row and file_hash_row[1] else game[6]

    no_intro_scoped = _column_exists(conn, "no_intro_main", "app_system_id")
    if no_intro_scoped:
        no_intro = cursor.execute(
            """
            SELECT nim.game_name
            FROM no_intro_main nim
            WHERE lower(nim.md5) = lower(?)
              AND nim.app_system_id = ?
            LIMIT 1
            """,
            (resolved_hash, game[7]),
        ).fetchone()
    else:
        no_intro = cursor.execute(
            """
            SELECT nim.game_name
            FROM no_intro_main nim
            WHERE lower(nim.md5) = lower(?)
            LIMIT 1
            """,
            (resolved_hash,),
        ).fetchone()

    tosec_scoped = _column_exists(conn, "tosec_main", "app_system_id")
    if tosec_scoped:
        tosec = cursor.execute(
            """
            SELECT tm.game_name
            FROM tosec_main tm
            WHERE lower(tm.md5) = lower(?)
              AND tm.app_system_id = ?
            LIMIT 1
            """,
            (resolved_hash, game[7]),
        ).fetchone()
    else:
        tosec = cursor.execute(
            """
            SELECT tm.game_name
            FROM tosec_main tm
            WHERE lower(tm.md5) = lower(?)
            LIMIT 1
            """,
            (resolved_hash,),
        ).fetchone()

    if game[5]:
        file_path = os.path.join(
            config.get("RootConfig", "softwareBackupStartDir"),
            game[5],
            resolved_file_name or "",
        )
    else:
        file_path = resolved_file_name or ""

    artwork_root = config.get("RootConfig", "softwareArtworkDir")

    def resolve_artwork_path(relative_or_absolute):
        if not relative_or_absolute:
            return None
        if os.path.isabs(relative_or_absolute):
            return relative_or_absolute
        return os.path.join(artwork_root, relative_or_absolute)

    return {
        "id": game[0],
        "game_name": game[1],
        "hash": resolved_hash,
        "filename": resolved_file_name,
        "path": file_path,
        "system_name": game[3],
        "system_short_name": game[4],
        "no_intro_system": game[3],
        "no_intro_game": no_intro[0] if no_intro else None,
        "tosec_system": game[3],
        "tosec_game": tosec[0] if tosec else None,
        "box_art_path": resolve_artwork_path(game[8]),
        "title_art_path": resolve_artwork_path(game[9]),
        "ingame_art_path": resolve_artwork_path(game[10]),
        "favorite_game": game[11],
        "release_date": game[12],
        "release_date_scraped": game[13],
        "game_genre": game[14],
        "game_genre_scraped": game[15],
        "cooperative": game[16],
        "cooperative_scraped": game[17],
        "max_players": game[18],
        "max_players_scraped": game[19],
        "description": game[20],
        "description_scraped": game[21],
        "user_notes": game[22],
    }


def SaveGameUserProperties(game_id, values, conn):
    """Persist user-controlled game properties for a selected game."""
    conn.execute(
        """
        UPDATE main_app
        SET favorite_game = ?,
            release_date = ?,
            game_genre = ?,
            cooperative = ?,
            max_players = ?,
            description = ?,
            user_notes = ?
        WHERE id = ?
        """,
        (
            values.get("favorite_game"),
            values.get("release_date"),
            values.get("game_genre"),
            values.get("cooperative"),
            values.get("max_players"),
            values.get("description"),
            values.get("user_notes"),
            game_id,
        ),
    )
    conn.commit()

    
if __name__ == '__main__':
    pass
    #test = GetSystemList()
    #print(test.keys())
    #AddNewSystem("Super Nintendo", "SNES", r"Roms/Snes/Gromulus")
    #ImportNewNoIntroDat("/home/nino/MyCode/Python/Active_prgs/Gromulus/_data/_dats/Nintendo - Super Nintendo Entertainment System (20230516-033614).dat")
    #AddNewRoms('/mnt/smb/HomeData/ninoborges/Emulation/Roms/Snes/Random2',"1",testOnly=True)
    #res = conn.execute("SELECT * FROM main_app LEFT JOIN no_intro_main ON main_app.md5 = no_intro_main.md5")
    #for h in res:
    #    print(h)
    #    print("\n")
    #GetGameListBySystem('snes')
    #GetSingleGameById('224')


Revision:	991
Committed:	Mon Mar 9 21:52:02 2026 UTC (2 weeks, 5 days ago) by nino.borges
Content type:	text/x-python
File size:	25311 byte(s)
Log Message:	I meant to have this as the commit message for 1.5 but I had an issue wiht the message. so I added some spaces to the files to force another commit. Gromulus v1.5: user metadata save workflow, schema expansion, and UI refactor - Added user-editable game metadata workflow with explicit Save button (no autosave). - Added dirty-state tracking and Save/Discard/Cancel prompts when navigating away or closing with unsaved changes. - Added DB schema support for new metadata fields: - favorite_game - release_date, release_date_scraped - game_genre, game_genre_scraped - cooperative, cooperative_scraped - max_players, max_players_scraped - Wired UI to user-first metadata precedence with _scraped fallback for release date, genre, cooperative, max players, and description. - Added release date display/storage conversion: - GUI display MM-DD-YYYY - DB storage YYYY-MM-DD - Refactored main game info panel: - moved hash/file/No-Intro/TOSEC detail fields into Reports -> Game Properties modal - added compact TOSEC/NoIntro match indicators - added Favorite, Release Date, Genre, Cooperative, Max Players, Description, and User Notes controls - Enhanced artwork previews from prior update: - larger preview boxes - aspect-ratio-preserving scaling - click-to-open full-size modal viewer - Updated schema/documentation files to stay aligned: - models.py - Database Dictonary.md - canonical DB utility schema/migration logic