update

OBJECTCATALOGUES/scripts/1-dump_tables.py

@@ -0,0 +1,799 @@
+import sqlite3
+import csv
+import os
+import glob
+import re
+import xml.etree.ElementTree as ET
+
+# -----------------------------
+# CONFIG
+# -----------------------------
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+BASE_ROOT = os.path.dirname(SCRIPT_DIR)
+TABLEDUMPS_DIR = os.path.join(BASE_ROOT, "TABLEDUMPS")
+
+FOLDER_ORDER = [
+    r"",
+    r"OBJECTCATALOGUES-MIX-DEC",
+    r"OBJECTCATALOGUES-MIX-BETA",
+    r"OBJECTCATALOGUES-MIX-DEV",
+]
+
+DB_PATTERNS = [
+    "ObjectCatalogue_5_*.sql"
+]
+
+XML_PATTERNS = [
+    "OBJECTCATALOGUE_*.xml",
+    "ObjectCatalogue_*.xml",
+]
+
+SHA1_SUFFIX_PATTERN = re.compile(r"_[0-9a-fA-F]{40}$")
+
+OBJECTS_HEADER = [
+    "ObjectIndex",
+    "ObjectId",
+    "Version",
+    "Location",
+    "InventoryEntryType",
+    "ArchiveTimeStamp",
+    "OdcSha1Digest",
+    "EntitlementIndex",
+    "RewardIndex",
+    "UserLocation",
+    "UserDateLastUsed",
+]
+
+METADATA_HEADER = [
+    "ObjectIndex",
+    "KeyName",
+    "Value",
+]
+
+TAGS_TRANSLATIONS = {
+    '00000000-00000000-00000000-00010047': {
+        'zh-TW': '牛仔帽（淺褐）',
+        'zh-HK': '牛仔帽（淺褐）',
+        'ja-JP': 'カウボーイハット（ライトブラウン）',
+        'ko-KR': '카우보이 모자(라이트 브라운)',
+        'de-DE': 'Beiger Cowboyhut',
+        'fr-FR': 'Chapeau cowboy camel',
+        'es-ES': 'Sombrero cowboy canela'
+    },
+    '00000000-00000000-00000000-00030027': {
+        'zh-TW': '連帽上衣（灰）',
+        'zh-HK': '連帽上衣（灰）',
+        'ja-JP': 'パーカー（グレー）',
+        'ko-KR': '파카(그레이)',
+        'de-DE': 'Grauer Kapuzenpulli',
+        'fr-FR': 'Haut capuche gris',
+        'es-ES': 'Jersey gris con capucha'
+    },
+    '00000000-00000000-00000000-00030054': {
+        'zh-TW': '軍外套（綠）',
+        'zh-HK': '軍外套（綠）',
+        'ja-JP': 'ミリタリージャケット（グリーン）',
+        'ko-KR': '밀리터리 재킷(그린)',
+        'de-DE': 'Grüne Militärjacke',
+        'fr-FR': 'Veste militaire verte',
+        'es-ES': 'Chaqueta militar verde'
+    },
+    '00000000-00000000-00000000-00030065': {
+        'zh-TW': '套頭杉（黑）',
+        'zh-HK': '套頭杉（黑）',
+        'ja-JP': 'タートルネック（ブラック）',
+        'ko-KR': '넥(블랙)',
+        'de-DE': 'Schwarzer Rollkragen',
+        'fr-FR': 'Col roulé noir',
+        'es-ES': 'Jersey cuello alto negro'
+    },
+    '00000000-00000000-00000000-00030076': {
+        'zh-TW': '綠色條紋開襟衫',
+        'zh-HK': '綠色條紋開襟衫',
+        'ja-JP': 'グリーンのストライプカーディガン',
+        'ko-KR': '녹색 줄무늬 카디건',
+        'de-DE': 'Grün gestreifte Strickjacke',
+        'fr-FR': 'Cardigan rayures vert',
+        'es-ES': 'Rebeca verde'
+    },
+    '00000000-00000000-00000000-00040013': {
+        'zh-TW': '運動褲（紅）',
+        'zh-HK': '運動褲（紅）',
+        'ja-JP': 'スウェットパンツ（レッド）',
+        'ko-KR': '팬츠(레드)',
+        'de-DE': 'Rote Jogginghose',
+        'fr-FR': 'Bas survêtement rouge',
+        'es-ES': 'Pantalones chándal rojos'
+    },
+    '00000000-00000000-00000000-00040026': {
+        'zh-TW': '灰色西裝長褲',
+        'zh-HK': '灰色西裝長褲',
+        'ja-JP': 'グレーのドレスパンツ',
+        'ko-KR': '회색 정장 바지',
+        'de-DE': 'Graue Anzughose',
+        'fr-FR': 'Pantalon ville gris',
+        'es-ES': 'Pantalones etiqueta grises'
+    },
+    '00000000-00000000-00000000-00040051': {
+        'zh-TW': '打折牛仔褲（黑）',
+        'zh-HK': '打折牛仔褲（黑）',
+        'ja-JP': '折り返したジーンズ（ブラック）',
+        'ko-KR': '접어올린 진(블랙)',
+        'de-DE': 'Schwarze Jeans umgeschlagen',
+        'fr-FR': 'Jean noir retroussé',
+        'es-ES': 'Vaqueros negros con dobladillo'
+    },
+    '00000000-00000000-00000000-00050012': {
+        'zh-TW': '籃球鞋（紅）',
+        'zh-HK': '籃球鞋（紅）',
+        'ja-JP': 'バスケットシューズ（レッド）',
+        'ko-KR': '농구화(레드)',
+        'de-DE': 'Rote Basketballstiefel',
+        'fr-FR': 'Baskets montantes rouges',
+        'es-ES': 'Botas baloncesto rojas'
+    },
+    '00000000-00000000-00000000-00050014': {
+        'zh-TW': '棕色時尚運動鞋',
+        'zh-HK': '棕色時尚運動鞋',
+        'ja-JP': 'ブラウンのファッションスニーカー',
+        'ko-KR': '갈색 패션 운동화',
+        'de-DE': 'Braune modische Turnschuhe',
+        'fr-FR': 'Tennis mode marron',
+        'es-ES': 'Zapatillas modernas marrones'
+    },
+    '00000000-00000000-00000000-00050019': {
+        'zh-TW': '懶人鞋（褐）',
+        'zh-HK': '懶人鞋（褐）',
+        'ja-JP': 'スリップオンスニーカー（ブラウン）',
+        'ko-KR': '슬립온 운동화(브라운)',
+        'de-DE': 'Braune Sportslipper',
+        'fr-FR': 'Tennis sans lacets marron',
+        'es-ES': 'Zapatillas sin cordones marrones'
+    },
+    '00000000-00000000-00000000-00050031': {
+        'zh-TW': '尖頭鞋（黑×白）',
+        'zh-HK': '尖頭鞋（黑×白）',
+        'ja-JP': 'トンガリ靴（ブラック×ホワイト）',
+        'ko-KR': '구두(블랙X화이트)',
+        'de-DE': 'Schwarz-weiße spitze Schuhe',
+        'fr-FR': 'Winkle-pickers noir blanc',
+        'es-ES': 'Zapatos punta negros blancos'
+    },
+    '00000000-00000000-00000000-00060002': {
+        'zh-TW': '細框眼鏡',
+        'zh-HK': '細框眼鏡',
+        'ja-JP': '細いフレームのメガネ',
+        'ko-KR': '얇은 테 안경',
+        'de-DE': 'Brille mit leichtem Rahmen',
+        'fr-FR': 'Lunettes fines',
+        'es-ES': 'Gafas montura ligera'
+    },
+    '00000000-00000000-00000000-01010062': {
+        'zh-TW': '綠色貝雷帽',
+        'zh-HK': '綠色貝雷帽',
+        'ja-JP': 'グリーンのベレー帽',
+        'ko-KR': '녹색 베레모',
+        'de-DE': 'Grüne Baskenmütze',
+        'fr-FR': 'Béret vert',
+        'es-ES': 'Boina verde'
+    },
+    '00000000-00000000-00000000-01030019': {
+        'zh-TW': '多層次T-shirt（灰×奶油）',
+        'zh-HK': '多層次T-shirt（灰×奶油）',
+        'ja-JP': 'レイヤードTシャツ（グリーン×クリーム）',
+        'ko-KR': '레이어드 셔츠(그린X크림)',
+        'de-DE': 'Grün-cremefarben Lagen T-Shirt',
+        'fr-FR': 'T-shirt vert crème',
+        'es-ES': 'Camiseta capas verde crema'
+    },
+    '00000000-00000000-00000000-01030036': {
+        'zh-TW': '牛仔衣（藍×褐）',
+        'zh-HK': '牛仔衣（藍×褐）',
+        'ja-JP': 'デニムジャケット（ブルー×ブラウン）',
+        'ko-KR': '재킷(블루X브라운)',
+        'de-DE': 'Blau-braune Jeansjacke',
+        'fr-FR': 'Veste jean bleu marron',
+        'es-ES': 'Chaqueta vaquera azul marrón'
+    },
+    '00000000-00000000-00000000-01030060': {
+        'zh-TW': '灰色背心配白色襯衫',
+        'zh-HK': '灰色背心配白色襯衫',
+        'ja-JP': 'ホワイトブラウスの上にグレーのタンクトップ',
+        'ko-KR': '흰색 블라우스 위에 회색 탱크톱',
+        'de-DE': 'Graues Tanktop über weißer Bluse',
+        'fr-FR': 'Débardeur gris sur chemisier blanc',
+        'es-ES': 'Chaleco gris sobre camiseta blanca'
+    },
+    '00000000-00000000-00000000-01030078': {
+        'zh-TW': '肚兜式禮服（雛菊）',
+        'zh-HK': '肚兜式禮服（雛菊）',
+        'ja-JP': 'ホルターネックドレス（デイジー）',
+        'ko-KR': '홀터넥 드레스(데이지)',
+        'de-DE': 'Neckholder-Top mit Blümchen',
+        'fr-FR': 'Dos marguerites',
+        'es-ES': 'Camiseta sin espalda con margaritas'
+    },
+    '00000000-00000000-00000000-01040022': {
+        'zh-TW': '運動褲（白）',
+        'zh-HK': '運動褲（白）',
+        'ja-JP': 'スウェットパンツ（ホワイト）',
+        'ko-KR': '팬츠(화이트)',
+        'de-DE': 'Weiße Jogginghose',
+        'fr-FR': 'Bas survêtement blanc',
+        'es-ES': 'Pantalones chándal blancos'
+    },
+    '00000000-00000000-00000000-01040039': {
+        'zh-TW': '短褲（花呢）',
+        'zh-HK': '短褲（花呢）',
+        'ja-JP': 'ショートパンツ（ツイード）',
+        'ko-KR': '팬츠(트위드)',
+        'de-DE': 'Tweed-Shorts',
+        'fr-FR': 'Short tweed',
+        'es-ES': 'Pantalones cortos tweed'
+    },
+    '00000000-00000000-00000000-01040061': {
+        'zh-TW': '摺腳牛仔褲（深藍）',
+        'zh-HK': '摺腳牛仔褲（深藍）',
+        'ja-JP': '折り返したジーンズ（ダークブルー）',
+        'ko-KR': '접어올린 진(다크 블루)',
+        'de-DE': 'Dunkelblaue Jeans umgeschlagen',
+        'fr-FR': 'Jean bleu foncé retroussé',
+        'es-ES': 'Vaqueros azules oscuros con dobladillo'
+    },
+    '00000000-00000000-00000000-01050024': {
+        'zh-TW': '籃球鞋（粉紅）',
+        'zh-HK': '籃球鞋（粉紅）',
+        'ja-JP': 'バスケットシューズ（ピンク）',
+        'ko-KR': '농구화(핑크)',
+        'de-DE': 'Pinke Basketballstiefel',
+        'fr-FR': 'Baskets montantes roses',
+        'es-ES': 'Botas baloncesto rosas'
+    },
+    '00000000-00000000-00000000-01050041': {
+        'zh-TW': '工作靴（黑）',
+        'zh-HK': '工作靴（黑）',
+        'ja-JP': 'ワークブーツ（ブラック）',
+        'ko-KR': '부츠(블랙)',
+        'de-DE': 'Schwarze Arbeitsstiefel',
+        'fr-FR': 'Bottes travail noires',
+        'es-ES': 'Botas trabajo negras'
+    },
+    '00000000-00000000-00000000-01050048': {
+        'zh-TW': '健走涼鞋（褐）',
+        'zh-HK': '健走涼鞋（褐）',
+        'ja-JP': 'ウォーキングサンダル（ブラウン）',
+        'ko-KR': '샌들(브라운)',
+        'de-DE': 'Braune Trekking-Sandalen',
+        'fr-FR': 'Sandales marche marron',
+        'es-ES': 'Sandalias para caminar marrones'
+    },
+    '00000000-00000000-00000000-01050056': {
+        'zh-TW': '紅色高跟鞋',
+        'zh-HK': '紅色高跟鞋',
+        'ja-JP': 'レッドのハイヒール',
+        'ko-KR': '빨간색 하이힐',
+        'de-DE': 'Rote Schuhe mit hohen Absätzen',
+        'fr-FR': 'Chaussures à talons rouges',
+        'es-ES': 'Zapatos de tacón rojos'
+    },
+    '00000000-00000000-00000000-01060001': {
+        'zh-TW': '粗框眼鏡',
+        'zh-HK': '粗框眼鏡',
+        'ja-JP': '太いフレームのメガネ',
+        'ko-KR': '두꺼운 테 안경',
+        'de-DE': 'Brille mit schwerem Rahmen',
+        'fr-FR': 'Lunettes épaisses',
+        'es-ES': 'Gafas montura pesada'
+    },
+    '00000000-00000000-00000000-01060017': {
+        'zh-TW': '星形太陽眼鏡',
+        'zh-HK': '星形太陽眼鏡',
+        'ja-JP': '星型サングラス',
+        'ko-KR': '선글래스',
+        'de-DE': 'Stern-Sonnenbrille',
+        'fr-FR': 'Lunettes soleil étoiles',
+        'es-ES': 'Gafas sol estrella'
+    },
+    '00000000-00000000-00000002-00000017': {
+        'ja-JP': 'チェア(サマーハウス)'
+    },
+    '00000000-00000000-00000002-00000031': {
+        'ja-JP': 'サボテン1'
+    },
+    '00000000-00000000-00000002-00000046': {
+        'ja-JP': 'あひるのおもちゃ'
+    }
+}
+
+
+def get_script_dir():
+    return os.path.dirname(os.path.abspath(__file__))
+
+
+def find_sqlite_files(folder):
+    files = []
+
+    for pattern in DB_PATTERNS:
+        files.extend(glob.glob(os.path.join(folder, pattern)))
+
+    return sorted(set(files), key=str.lower)
+
+
+def find_xml_files(folder):
+    files = []
+
+    for pattern in XML_PATTERNS:
+        files.extend(glob.glob(os.path.join(folder, pattern)))
+
+    return sorted(set(files), key=str.lower)
+
+
+def strip_sha1(filename):
+    base = os.path.splitext(os.path.basename(filename))[0]
+    return SHA1_SUFFIX_PATTERN.sub("", base)
+
+
+def decode_blob(value):
+    try:
+        return value.decode("utf-8")
+    except (UnicodeDecodeError, AttributeError):
+        if isinstance(value, (bytes, bytearray)):
+            return value.hex().upper()[:40]
+
+        return value
+
+
+def ensure_dir(path):
+    os.makedirs(path, exist_ok=True)
+
+
+def csv_exists(base_name, out_dir):
+    objects_csv = os.path.join(
+        out_dir,
+        f"{base_name}_Objects.csv"
+    )
+
+    metadata_csv = os.path.join(
+        out_dir,
+        f"{base_name}_Metadata.csv"
+    )
+
+    return (
+        os.path.exists(objects_csv)
+        or os.path.exists(metadata_csv)
+    )
+
+
+def remove_xml_namespace(tag):
+    return tag.rsplit("}", 1)[-1]
+
+
+def parse_hex_integer(value, default=0):
+    if value is None:
+        return default
+
+    value = value.strip()
+
+    if not value:
+        return default
+
+    try:
+        return int(value, 16)
+    except ValueError:
+        print(f"[WARN] Invalid hexadecimal integer: {value}")
+        return default
+
+
+def parse_decimal_integer(value, default=0):
+    if value is None:
+        return default
+
+    value = value.strip()
+
+    if not value:
+        return default
+
+    try:
+        return int(value)
+    except ValueError:
+        print(f"[WARN] Invalid decimal integer: {value}")
+        return default
+
+
+def extract_table(cursor, table_name, out_csv):
+    cursor.execute(f"SELECT * FROM {table_name}")
+    rows = cursor.fetchall()
+
+    with open(
+        out_csv,
+        "w",
+        newline="",
+        encoding="utf-8"
+    ) as csv_file:
+
+        writer = csv.writer(csv_file)
+
+        writer.writerow([
+            description[0]
+            for description in cursor.description
+        ])
+
+        for row in rows:
+            cleaned = [
+                decode_blob(value)
+                if isinstance(value, (bytes, bytearray))
+                else value
+                for value in row
+            ]
+
+            writer.writerow(cleaned)
+
+
+def process_db(db_path, out_dir):
+    base_name = strip_sha1(db_path)
+
+    objects_csv = os.path.join(
+        out_dir,
+        f"{base_name}_Objects.csv"
+    )
+
+    metadata_csv = os.path.join(
+        out_dir,
+        f"{base_name}_Metadata.csv"
+    )
+
+    if csv_exists(base_name, out_dir):
+        print(f"[SKIP SQL] Already exists, nothing changed: {base_name}")
+        return
+
+    print(f"[PROCESS SQL] {db_path}")
+
+    conn = None
+
+    try:
+        conn = sqlite3.connect(db_path)
+        conn.text_factory = bytes
+
+        cursor = conn.cursor()
+
+        extract_table(
+            cursor,
+            "Objects",
+            objects_csv
+        )
+
+        extract_table(
+            cursor,
+            "Metadata",
+            metadata_csv
+        )
+
+        print(f"[DONE SQL] {base_name}")
+
+    except sqlite3.Error as error:
+        print(f"[ERROR SQL] {db_path}: {error}")
+
+        for output_file in (objects_csv, metadata_csv):
+            if os.path.exists(output_file):
+                os.remove(output_file)
+
+    finally:
+        if conn is not None:
+            conn.close()
+
+
+def get_xml_objects(root):
+    for element in root.iter():
+        if remove_xml_namespace(element.tag).lower() == "object":
+            yield element
+
+
+def build_xml_rows(xml_path):
+    tree = ET.parse(xml_path)
+    root = tree.getroot()
+
+    objects_rows = []
+    metadata_rows = []
+
+    skip_if_blank_elements = {
+        "SCENE_ENTITLEMENT",
+        "ENTITLEMENT_ID",
+        "CATEGORY_ID",
+        "PRODUCT_ID",
+        "TITLE_ID",
+        "COMMUNICATION_ID",
+    }
+
+    skip_if_dummy_elements = {
+        "ENTITLEMENT_ID",
+        "CATEGORY_ID",
+        "PRODUCT_ID",
+    }
+
+    clothing_value_replacements = {
+        "TORS LEGS": "OUTFITS",
+        "TORS LEGS FEET": "OUTFITS",
+        "OUTFITS TORS HANDS LEGS FEET HAT": "OUTFITS",
+        "LEGS FEET": "LEGS",
+        "TORS LEGS FEET OUTFITS": "OUTFITS",
+        "TORSO": "TORS",
+        "TORS LEGS OUTFITS": "OUTFITS",
+    }
+
+    furniture_value_replacements = {
+        "PICTURE FRAME": "FRAME",
+    }
+
+    category_value_replacements = {
+        "24-NPUR30151_00": "UP0024-NPUR30151_00",
+        "LUA REWARD": "LUA_REWARD",
+        "UP9000-NPUQ0001_00": "UP9000-NPUQ00001_00",
+        "UUP9000-NPUQ00001_00": "UP9000-NPUQ00001_00",
+        "UP9000-NPUQ00010_": "UP9000-NPUQ00010_00",
+        "HP9000-NPHQ00009": "HP9000-NPHQ00009_00",
+        "HT4010-NPHR00022_00'": "HT4010-NPHR00022_00",
+        "ET0002-NPER00035_00V": "ET0002-NPER00035_00",
+        "JT4001-NPJR50210": "JT4001-NPJR50210_00",
+        "JP9000-NPJQ50100": "JP9000-NPJQ50100_00",
+        "JP9002-NPJQ50280": "JP9002-NPJQ50280_00",
+        "JP0082-NPJR50150_0": "JP0082-NPJR50150_00",
+        "JP0043-NPJR50420": "JP0043-NPJR50420_00",
+    }
+
+    product_value_replacements = {
+        "LUA REWARD": "LUA_REWARD",
+    }
+
+    object_index = 0
+
+    for object_element in get_xml_objects(root):
+        object_index += 1
+
+        object_id = object_element.get("uuid", "").strip()
+
+        version = parse_decimal_integer(
+            object_element.get("vers"),
+            default=0
+        )
+
+        archive_timestamp = parse_hex_integer(
+            object_element.get("timestamp"),
+            default=0
+        )
+
+        odc_sha1 = object_element.get("sha1", "").strip().upper()
+
+        objects_rows.append([
+            object_index,
+            object_id,
+            version,
+            1,
+            "",
+            archive_timestamp,
+            odc_sha1,
+            "",
+            "",
+            0,
+            "",
+        ])
+
+        seen_tags = set()
+        seen_entitlement_ids = set()
+
+        for child in object_element:
+            tag_name = remove_xml_namespace(child.tag).upper()
+            value = (child.text or "").strip()
+
+            if tag_name in skip_if_blank_elements and not value:
+                continue
+
+            if (
+                tag_name in skip_if_dummy_elements
+                and value.lower() == "dummy"
+            ):
+                continue
+
+            if tag_name in {
+                "CLOTHING",
+                "FURNITURE",
+                "WORLD_MAP",
+                "ACTIVE",
+                "SCENE_ENTITLEMENT",
+                "SCENE_TYPE",
+                "LEGAL_TAG",
+                "CLAN",
+                "MINI_GAME",
+                "CATEGORY_ID",
+                "PRODUCT_ID",
+            }:
+                value = value.upper()
+
+            if tag_name == "CLOTHING":
+                value = " ".join(value.split())
+
+                value = clothing_value_replacements.get(
+                    value,
+                    value
+                )
+
+            elif tag_name == "FURNITURE":
+                value = " ".join(value.split())
+
+                value = furniture_value_replacements.get(
+                    value,
+                    value
+                )
+
+            elif tag_name == "CATEGORY_ID":
+                value = " ".join(value.split())
+
+                value = category_value_replacements.get(
+                    value,
+                    value
+                )
+
+            elif tag_name == "PRODUCT_ID":
+                value = " ".join(value.split())
+
+                value = product_value_replacements.get(
+                    value,
+                    value
+                )
+
+            if tag_name == "TAGS":
+                lang = child.get("lang", "").strip()
+
+                if object_id in TAGS_TRANSLATIONS:
+                    replacement = TAGS_TRANSLATIONS[object_id].get(lang)
+
+                    if replacement is not None:
+                        value = replacement
+
+                if value in seen_tags:
+                    continue
+
+                seen_tags.add(value)
+                values = [value]
+
+            elif tag_name == "ENTITLEMENT_ID":
+                if value in seen_entitlement_ids:
+                    continue
+
+                seen_entitlement_ids.add(value)
+                values = [value]
+
+            elif tag_name == "TITLE_ID":
+                values = value.split() if value else [""]
+
+            elif tag_name == "WORLD_MAP":
+                values = value.split() if value else [""]
+
+            else:
+                values = [value]
+
+            for metadata_value in values:
+                metadata_rows.append([
+                    object_index,
+                    tag_name,
+                    metadata_value,
+                ])
+
+    return objects_rows, metadata_rows
+
+
+def write_xml_csv_files(
+    objects_csv,
+    metadata_csv,
+    objects_rows,
+    metadata_rows
+):
+    with open(
+        objects_csv,
+        "w",
+        newline="",
+        encoding="utf-8"
+    ) as csv_file:
+
+        writer = csv.writer(csv_file)
+        writer.writerow(OBJECTS_HEADER)
+        writer.writerows(objects_rows)
+
+    with open(
+        metadata_csv,
+        "w",
+        newline="",
+        encoding="utf-8"
+    ) as csv_file:
+
+        writer = csv.writer(csv_file)
+        writer.writerow(METADATA_HEADER)
+        writer.writerows(metadata_rows)
+
+
+def process_xml(xml_path, out_dir):
+    base_name = strip_sha1(xml_path)
+
+    objects_csv = os.path.join(
+        out_dir,
+        f"{base_name}_Objects.csv"
+    )
+
+    metadata_csv = os.path.join(
+        out_dir,
+        f"{base_name}_Metadata.csv"
+    )
+
+    if csv_exists(base_name, out_dir):
+        print(f"[SKIP XML] Already exists, nothing changed: {base_name}")
+        return
+
+    print(f"[PROCESS XML] {xml_path}")
+
+    try:
+        objects_rows, metadata_rows = build_xml_rows(xml_path)
+
+        write_xml_csv_files(
+            objects_csv,
+            metadata_csv,
+            objects_rows,
+            metadata_rows
+        )
+
+        print(
+            f"[DONE XML] {base_name}: "
+            f"{len(objects_rows)} object row(s), "
+            f"{len(metadata_rows)} metadata row(s)"
+        )
+
+    except (ET.ParseError, OSError, ValueError) as error:
+        print(f"[ERROR XML] {xml_path}: {error}")
+
+        for output_file in (objects_csv, metadata_csv):
+            if os.path.exists(output_file):
+                os.remove(output_file)
+
+
+def main():
+    script_dir = get_script_dir()
+    out_dir = TABLEDUMPS_DIR
+
+    ensure_dir(out_dir)
+
+    print(f"Script folder: {script_dir}")
+    print(f"Base folder: {BASE_ROOT}")
+    print(f"Output folder: {out_dir}")
+    print()
+
+    for folder in FOLDER_ORDER:
+        if folder:
+            folder_path = os.path.join(BASE_ROOT, folder)
+        else:
+            folder_path = BASE_ROOT
+
+        print("--------------------------------------------------")
+        print(f"[FOLDER] {folder_path}")
+        print("--------------------------------------------------")
+
+        if not os.path.isdir(folder_path):
+            print(f"[WARN] Missing folder: {folder_path}")
+            print()
+            continue
+
+        db_files = find_sqlite_files(folder_path)
+
+        for db_file in db_files:
+            process_db(db_file, out_dir)
+
+        xml_files = find_xml_files(folder_path)
+
+        for xml_file in xml_files:
+            process_xml(xml_file, out_dir)
+
+        print()
+
+    input("")
+
+
+if __name__ == "__main__":
+    main()

OBJECTCATALOGUES/scripts/2-combine_tables.py

@@ -0,0 +1,729 @@
+import csv
+import os
+import re
+from pathlib import Path
+from collections import defaultdict
+
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+BASE_DIR = SCRIPT_DIR.parent
+TABLEDUMPS_DIR = BASE_DIR / "TABLEDUMPS"
+
+OBJECTS_SUFFIX = "_Objects.csv"
+METADATA_SUFFIX = "_Metadata.csv"
+COMBINED_SUFFIX = "_Combined.csv"
+
+ERROR_LOG = BASE_DIR / "errors.log"
+
+REMOVE_OBJECT_COLUMNS = {
+    "Location",
+    "InventoryEntryType",
+    "EntitlementIndex",
+    "RewardIndex",
+    "UserLocation",
+    "UserDateLastUsed",
+}
+
+METADATA_COLUMNS = [
+    "CLOTHING",
+    "RIGS",
+    "GENDER",
+    "PORTABLE",
+    "MINI_GAME",
+    "ACTIVE",
+    "TARGETABLE",
+    "ARCADE_GAME",
+    "FURNITURE",
+    "HOST_HEAT",
+    "MAIN_HEAT",
+    "NET_HEAT",
+    "PPU_HEAT",
+    "VRAM_HEAT",
+    "EMBEDDED_OBJECT",
+    "SCENE_ENTITLEMENT",
+    "SCENE_TYPE",
+    "TAGS",
+    "WORLD_MAP",
+    "LEGAL_TAG",
+    "CLAN",
+    "LPID",
+    "CATEGORY_ID",
+    "PRODUCT_ID",
+    "ENTITLEMENT_ID",
+    "COMMUNICATION_ID",
+    "TITLE_ID",
+]
+
+TYPE_COLUMNS = [
+    "CLOTHING",
+    "GENDER",
+    "PORTABLE",
+    "MINI_GAME",
+    "ARCADE_GAME",
+    "FURNITURE",
+    "ACTIVE",
+    "TARGETABLE",
+    "SCENE_ENTITLEMENT",
+    "SCENE_TYPE",
+    "EMBEDDED_OBJECT",
+]
+
+TYPE_COLUMNS_MINIGAME_AFTER_FURNITURE = [
+    "CLOTHING",
+    "GENDER",
+    "PORTABLE",
+    "ARCADE_GAME",
+    "FURNITURE",
+    "MINI_GAME",
+    "ACTIVE",
+    "TARGETABLE",
+    "SCENE_ENTITLEMENT",
+    "SCENE_TYPE",
+    "EMBEDDED_OBJECT",
+]
+
+TYPE_TITLE_ONLY_COLUMNS = {
+    "PORTABLE",
+    "MINI_GAME",
+    "ACTIVE",
+    "TARGETABLE",
+    "ARCADE_GAME",
+    "EMBEDDED_OBJECT",
+}
+
+TYPE_TITLE_AND_VALUE_COLUMNS = {
+    "CLOTHING",
+    "FURNITURE",
+    "SCENE_TYPE",
+    "SCENE_ENTITLEMENT",
+}
+
+SORT_VALUES_COLUMNS = {
+    "WORLD_MAP",
+    "CATEGORY_ID",
+    "PRODUCT_ID",
+    "ENTITLEMENT_ID",
+}
+
+GENDER_RIGS = {
+    "00000000-00000000-00000010-00000000": "MALE",
+    "00000000-00000000-00000010-00000001": "FEMALE",
+}
+
+CLOTHING_REPLACEMENTS = {
+    "TORS|LEGS": "OUTFITS",
+    "TORS|LEGS|FEET": "OUTFITS",
+    "LEGS|FEET": "LEGS",
+    "TORS|LEGS|FEET|OUTFITS": "OUTFITS",
+    "TORSO": "TORS",
+    "TORS|LEGS|OUTFITS": "OUTFITS",
+    "LEGS|TORS|FEET": "OUTFITS",
+    "TORS|AND|LEGS": "OUTFITS",
+    "TORS|LEG": "OUTFITS",
+}
+
+CATEGORY_REPLACEMENTS = {
+    "5|EVIL|RESIDENT|T-SHIRT": "RESIDENT|EVIL|5|T-SHIRT",
+    "AND|BLACK|DENIM|LEGGINGS|RED|SHORTS|STILETTOS|WITH": "RED|STILETTOS|WITH|BLACK|DENIM|SHORTS|AND|LEGGINGS",
+    "24-NPUR30151_00": "UP0024-NPUR30151_00",
+    "LUA|REWARD": "LUA_REWARD",
+    "UP9000-NPUQ0001_00": "UP9000-NPUQ00001_00",
+    "UUP9000-NPUQ00001_00": "UP9000-NPUQ00001_00",
+    "UP9000-NPUQ00010_": "UP9000-NPUQ00010_00",
+    "HP9000-NPHQ00009": "HP9000-NPHQ00009_00",
+    "HT4010-NPHR00022_00'": "HT4010-NPHR00022_00",
+    "ET0002-NPER00035_00V": "ET0002-NPER00035_00",
+    "JT4001-NPJR50210": "JT4001-NPJR50210_00",
+    "JP9000-NPJQ50100": "JP9000-NPJQ50100_00",
+    "JP9002-NPJQ50280": "JP9002-NPJQ50280_00",
+    "JP0082-NPJR50150_0": "JP0082-NPJR50150_00",
+    "JP0043-NPJR50420": "JP0043-NPJR50420_00",
+}
+
+PRODUCT_REPLACEMENTS = {
+    "LUA|REWARD": "LUA_REWARD",
+}
+
+FURNITURE_REPLACEMENTS = {
+    "PICTURE|FRAME": "FRAME",
+}
+
+DATE_PATTERN = re.compile(r"^(.*?)(\d{4}-\d{2}-\d{2})(.*)$")
+
+
+def log_error(message):
+    with open(ERROR_LOG, "a", encoding="utf-8", newline="\n") as log_file:
+        log_file.write(message + "\n")
+
+
+def strip_suffix(filename, suffix):
+    if filename.endswith(suffix):
+        return filename[:-len(suffix)]
+
+    return filename
+
+
+def get_catalogue_parts(stem):
+    match = DATE_PATTERN.match(stem)
+
+    if not match:
+        return None
+
+    prefix = match.group(1)
+    date = match.group(2)
+    suffix = match.group(3)
+
+    return prefix, date, suffix
+
+
+def get_objectcatalogue_5_date(stem):
+    parts = stem.split("_")
+
+    if len(parts) >= 4:
+        date = parts[3]
+
+        if re.fullmatch(r"\d{4}-\d{2}-\d{2}", date):
+            return date
+
+    return "0000-00-00"
+
+
+def get_objectcatalogue_date(stem):
+    parts = stem.split("_")
+
+    if len(parts) >= 2:
+        date = parts[1]
+
+        if re.fullmatch(r"\d{4}-\d{2}-\d{2}", date):
+            return date
+
+    return "0000-00-00"
+
+
+def find_objects_files():
+    objects = {}
+
+    for path in TABLEDUMPS_DIR.glob(f"*{OBJECTS_SUFFIX}"):
+        stem = strip_suffix(path.name, OBJECTS_SUFFIX)
+        objects[stem] = path
+
+    return objects
+
+
+def find_metadata_files():
+    metadata = {}
+
+    for path in TABLEDUMPS_DIR.glob(f"*{METADATA_SUFFIX}"):
+        stem = strip_suffix(path.name, METADATA_SUFFIX)
+        metadata[stem] = path
+
+    return metadata
+
+
+def catalogue_sort_key(stem):
+    lower_stem = stem.lower()
+
+    if lower_stem.startswith("objectcatalogue_"):
+        return 0, lower_stem
+
+    return 1, lower_stem
+
+
+def find_best_objects_file(metadata_stem, objects_files):
+    if metadata_stem in objects_files:
+        return objects_files[metadata_stem]
+
+    metadata_parts = get_catalogue_parts(metadata_stem)
+
+    if metadata_parts is None:
+        return None
+
+    metadata_prefix, metadata_date, metadata_suffix = metadata_parts
+
+    candidates = []
+
+    for objects_stem, objects_path in objects_files.items():
+        objects_parts = get_catalogue_parts(objects_stem)
+
+        if objects_parts is None:
+            continue
+
+        objects_prefix, objects_date, objects_suffix = objects_parts
+
+        if objects_prefix != metadata_prefix:
+            continue
+
+        if objects_suffix != metadata_suffix:
+            continue
+
+        if objects_date > metadata_date:
+            continue
+
+        candidates.append((objects_date, objects_path))
+
+    if not candidates:
+        return None
+
+    candidates.sort(key=lambda item: item[0], reverse=True)
+
+    return candidates[0][1]
+
+
+def normalize_keyname(keyname):
+    return keyname.strip().upper()
+
+
+def version_to_txxx(version):
+    version = str(version).strip()
+
+    if not version:
+        version = "0"
+
+    try:
+        version_int = int(version)
+    except ValueError:
+        version_int = 0
+
+    return f"T{version_int:03d}"
+
+
+def timestamp_to_hex(value):
+    value = str(value).strip()
+
+    if not value:
+        return ""
+
+    try:
+        timestamp_int = int(value)
+    except ValueError:
+        return value.upper()
+
+    return f"{timestamp_int:X}"
+
+
+def normalize_joined_values(values):
+    cleaned_values = []
+
+    for value in values:
+        value = str(value).strip().upper()
+
+        if not value:
+            continue
+
+        cleaned_values.append(value)
+
+    return "|".join(cleaned_values)
+
+
+def add_field_name(column, value, has_keyname):
+    if not has_keyname:
+        return ""
+
+    value = str(value).strip()
+
+    if not value:
+        return f"{column}|"
+
+    return f"{column}|{value}|"
+
+
+def strip_field_name(column, value):
+    value = str(value).strip()
+
+    prefix = f"{column}|"
+
+    if value.startswith(prefix):
+        value = value[len(prefix):]
+
+    if value.endswith("|"):
+        value = value[:-1]
+
+    return value
+
+
+def furniture_has_value(value):
+    value = str(value).strip()
+
+    if not value:
+        return False
+
+    if not value.startswith("FURNITURE|"):
+        return False
+
+    return value != "FURNITURE|"
+
+
+def add_type_field_name(column, value):
+    value = str(value).strip()
+
+    if not value:
+        return ""
+
+    if column == "GENDER":
+        return f"{value}|"
+
+    if column in TYPE_TITLE_ONLY_COLUMNS:
+        return f"{column}|"
+
+    if column in TYPE_TITLE_AND_VALUE_COLUMNS:
+        return value
+
+    return value
+
+
+def build_type_value(combined_row):
+    type_value = ""
+
+    if (
+        furniture_has_value(combined_row.get("FURNITURE", ""))
+        and combined_row.get("MINI_GAME", "")
+    ):
+        type_columns = TYPE_COLUMNS_MINIGAME_AFTER_FURNITURE
+    else:
+        type_columns = TYPE_COLUMNS
+
+    for column in type_columns:
+        value = add_type_field_name(
+            column,
+            combined_row.get(column, "")
+        )
+
+        if value:
+            type_value += value
+
+    return type_value
+
+
+def normalize_clothing_values(values):
+    joined_value = normalize_joined_values(values)
+
+    return CLOTHING_REPLACEMENTS.get(joined_value, joined_value)
+
+
+def normalize_category_values(values):
+    joined_value = normalize_joined_values(values)
+
+    return CATEGORY_REPLACEMENTS.get(joined_value, joined_value)
+
+
+def normalize_product_values(values):
+    joined_value = normalize_joined_values(values)
+
+    return PRODUCT_REPLACEMENTS.get(joined_value, joined_value)
+
+
+def normalize_furniture_values(values):
+    joined_value = normalize_joined_values(values)
+
+    return FURNITURE_REPLACEMENTS.get(joined_value, joined_value)
+
+
+def read_objects_csv(objects_path):
+    with open(objects_path, "r", encoding="utf-8-sig", newline="") as csv_file:
+        reader = csv.DictReader(csv_file)
+
+        if reader.fieldnames is None:
+            raise ValueError(f"Missing header: {objects_path}")
+
+        if "ObjectIndex" not in reader.fieldnames:
+            raise ValueError(f"Missing ObjectIndex column: {objects_path}")
+
+        if "ObjectId" not in reader.fieldnames:
+            raise ValueError(f"Missing ObjectId column: {objects_path}")
+
+        if "Version" not in reader.fieldnames:
+            raise ValueError(f"Missing Version column: {objects_path}")
+
+        if "ArchiveTimeStamp" not in reader.fieldnames:
+            raise ValueError(f"Missing ArchiveTimeStamp column: {objects_path}")
+
+        objects_header = [
+            column
+            for column in reader.fieldnames
+            if column not in REMOVE_OBJECT_COLUMNS
+        ]
+
+        final_objects_header = []
+
+        for column in objects_header:
+            final_objects_header.append(column)
+
+            if column == "Version":
+                final_objects_header.append("UUID_TXXX")
+
+            if column == "ArchiveTimeStamp":
+                final_objects_header.append("ArchiveTimeStampHex")
+
+            if column == "OdcSha1Digest":
+                final_objects_header.append("TYPE")
+
+        rows = []
+
+        for row in reader:
+            object_index = row.get("ObjectIndex", "").strip()
+
+            if not object_index:
+                log_error(f"[WARN] Blank ObjectIndex in Objects CSV: {objects_path}")
+                continue
+
+            object_id = row.get("ObjectId", "").strip()
+            version = row.get("Version", "").strip()
+            archive_timestamp = row.get("ArchiveTimeStamp", "").strip()
+
+            row["UUID_TXXX"] = f"{object_id}_{version_to_txxx(version)}"
+            row["ArchiveTimeStampHex"] = timestamp_to_hex(archive_timestamp)
+            row["TYPE"] = ""
+
+            clean_row = {}
+
+            for column in final_objects_header:
+                clean_row[column] = row.get(column, "")
+
+            rows.append(clean_row)
+
+    return final_objects_header, rows
+
+
+def read_metadata_csv(metadata_path):
+    metadata_by_object_index = defaultdict(lambda: defaultdict(list))
+    unknown_keynames = set()
+
+    with open(metadata_path, "r", encoding="utf-8-sig", newline="") as csv_file:
+        reader = csv.DictReader(csv_file)
+
+        if reader.fieldnames is None:
+            raise ValueError(f"Missing header: {metadata_path}")
+
+        required_columns = {"ObjectIndex", "KeyName", "Value"}
+        missing_columns = required_columns - set(reader.fieldnames)
+
+        if missing_columns:
+            raise ValueError(
+                f"Missing Metadata column(s) {sorted(missing_columns)}: {metadata_path}"
+            )
+
+        for row_number, row in enumerate(reader, start=2):
+            object_index = row.get("ObjectIndex", "").strip()
+            raw_keyname = row.get("KeyName", "").strip()
+            value = row.get("Value", "")
+
+            if not object_index:
+                log_error(
+                    f"[WARN] Blank ObjectIndex in Metadata CSV: {metadata_path}, row {row_number}"
+                )
+                continue
+
+            if not raw_keyname:
+                log_error(
+                    f"[WARN] Blank KeyName in Metadata CSV: {metadata_path}, row {row_number}"
+                )
+                continue
+
+            keyname = normalize_keyname(raw_keyname)
+
+            if keyname not in METADATA_COLUMNS:
+                unknown_keynames.add(raw_keyname)
+                continue
+
+            metadata_by_object_index[object_index][keyname].append(value)
+
+    for keyname in sorted(unknown_keynames):
+        log_error(f"[UNKNOWN KEYNAME] {metadata_path.name}: {keyname}")
+
+    return metadata_by_object_index
+
+
+def get_gender_from_rigs(rig_values):
+    gender_values = []
+
+    for rig_value in rig_values:
+        rig_value = str(rig_value).strip()
+        gender = GENDER_RIGS.get(rig_value)
+
+        if gender is None:
+            continue
+
+        if gender not in gender_values:
+            gender_values.append(gender)
+
+    return "|".join(gender_values)
+
+
+def combine_pair(objects_path, metadata_path):
+    metadata_stem = strip_suffix(metadata_path.name, METADATA_SUFFIX)
+    output_path = TABLEDUMPS_DIR / f"{metadata_stem}{COMBINED_SUFFIX}"
+
+    if output_path.exists():
+        print(f"[SKIP] Already exists, nothing changed: {output_path.name}")
+        return
+
+    objects_header, objects_rows = read_objects_csv(objects_path)
+    metadata_by_object_index = read_metadata_csv(metadata_path)
+
+    combined_header = objects_header + METADATA_COLUMNS
+
+    with open(output_path, "w", encoding="utf-8", newline="") as csv_file:
+        writer = csv.DictWriter(
+            csv_file,
+            fieldnames=combined_header,
+            extrasaction="ignore"
+        )
+
+        writer.writeheader()
+
+        for object_row in objects_rows:
+            object_index = object_row.get("ObjectIndex", "").strip()
+        
+            metadata_values = metadata_by_object_index.get(object_index, {})
+            combined_row = dict(object_row)
+        
+            for column in METADATA_COLUMNS:
+                if column == "GENDER":
+                    combined_row[column] = get_gender_from_rigs(
+                        metadata_values.get("RIGS", [])
+                    )
+                    continue
+
+                values = metadata_values.get(column, [])
+                has_keyname = column in metadata_values
+
+                if column in SORT_VALUES_COLUMNS:
+                    values = sorted(values, key=str.lower)
+
+                if column == "CLOTHING":
+                    normalized_value = normalize_clothing_values(values)
+
+                elif column == "CATEGORY_ID":
+                    normalized_value = normalize_category_values(values)
+
+                elif column == "PRODUCT_ID":
+                    normalized_value = normalize_product_values(values)
+
+                elif column == "FURNITURE":
+                    normalized_value = normalize_furniture_values(values)
+
+                else:
+                    normalized_value = "|".join(values)
+
+                combined_row[column] = add_field_name(
+                    column,
+                    normalized_value,
+                    has_keyname
+                )
+
+            if not combined_row.get("CLOTHING", ""):
+                rigs_value = combined_row.get("RIGS", "")
+
+                if rigs_value.startswith("RIGS|"):
+                    combined_row["CLOTHING"] = "CLOTHING|"
+
+            if combined_row.get("FURNITURE", ""):
+                rigs_value = combined_row.get("RIGS", "")
+
+                if rigs_value.startswith("RIGS|"):
+                    combined_row["RIGS"] = strip_field_name(
+                        "RIGS",
+                        rigs_value
+                    )
+
+            combined_row["TYPE"] = build_type_value(combined_row)
+
+            writer.writerow(combined_row)
+
+    print(f"[DONE] {output_path.name}")
+
+
+def main():
+    print(f"Script folder: {SCRIPT_DIR}")
+    print(f"Base folder: {BASE_DIR}")
+    print(f"Table dumps folder: {TABLEDUMPS_DIR}")
+    print()
+
+    if not TABLEDUMPS_DIR.exists():
+        print("[ERROR] TABLEDUMPS folder does not exist.")
+        print(f"Missing folder: {TABLEDUMPS_DIR}")
+        input("")
+        return
+
+    if ERROR_LOG.exists():
+        ERROR_LOG.unlink()
+
+    objects_files = find_objects_files()
+    metadata_files = find_metadata_files()
+
+    print(f"Objects CSV files: {len(objects_files)}")
+    print(f"Metadata CSV files: {len(metadata_files)}")
+    print()
+
+    if not objects_files:
+        print("[ERROR] No *_Objects.csv files found.")
+        input("")
+        return
+
+    if not metadata_files:
+        print("[ERROR] No *_Metadata.csv files found.")
+        input("")
+        return
+
+    objectcatalogue_5_stems = []
+    objectcatalogue_stems = []
+    other_stems = []
+
+    for metadata_stem in metadata_files.keys():
+        lower_stem = metadata_stem.lower()
+
+        if lower_stem.startswith("objectcatalogue_5_"):
+            objectcatalogue_5_stems.append(metadata_stem)
+
+        elif lower_stem.startswith("objectcatalogue_"):
+            objectcatalogue_stems.append(metadata_stem)
+
+        else:
+            other_stems.append(metadata_stem)
+
+    sorted_metadata_stems = (
+        sorted(
+            objectcatalogue_5_stems,
+            key=get_objectcatalogue_5_date,
+            reverse=True
+        )
+        + sorted(
+            objectcatalogue_stems,
+            key=get_objectcatalogue_date,
+            reverse=True
+        )
+        + sorted(other_stems, key=catalogue_sort_key)
+    )
+
+    for metadata_stem in sorted_metadata_stems:
+        metadata_path = metadata_files[metadata_stem]
+        objects_path = find_best_objects_file(metadata_stem, objects_files)
+
+        if objects_path is None:
+            log_error(f"[MISSING OBJECTS CSV] {metadata_path.name}")
+            print(f"[SKIP] Missing Objects CSV for {metadata_path.name}")
+            continue
+
+        print(f"[COMBINE] {objects_path.name}")
+        print(f"      + {metadata_path.name}")
+
+        try:
+            combine_pair(objects_path, metadata_path)
+        except Exception as error:
+            log_error(
+                f"[ERROR] Failed combining {objects_path.name} + {metadata_path.name}: {error}"
+            )
+            print(f"[ERROR] {metadata_path.name}: {error}")
+
+    print()
+
+    if ERROR_LOG.exists():
+        print(f"Finished with log: {ERROR_LOG}")
+    else:
+        print("Finished with no errors.")
+
+    input("")
+
+
+if __name__ == "__main__":
+    main()

OBJECTCATALOGUES/scripts/3-create_logs.py

@@ -0,0 +1,737 @@
+import csv
+import os
+import glob
+import re
+from datetime import datetime
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+BASE_DIR = os.path.dirname(SCRIPT_DIR)
+
+TARGET_DIR = os.path.join(BASE_DIR, "TABLEDUMPS")
+OUTPUT_FILE = os.path.join(BASE_DIR, "uniqueobjects.txt")
+FIRST_INTRO_OUTPUT_FILE = os.path.join(BASE_DIR, "uuidfirstintroduced.txt")
+DEBUG_UUID_LOG_FILE = os.path.join(BASE_DIR, "debug.log")
+
+DEBUG_UUID_LOG_ENABLED = False
+
+DEBUG_UUIDS = {
+    "C080CDE0-DE51455D-BF85BC62-EF65634A",
+    "0BB99D3D-11BD4A6C-9F1300E3-3A8E2592",
+    "CAFEF00D-BEEFF00D-FEEDBEEF-000010A2",
+}
+
+BUILD_MATCHES = {
+    "Env_SCEA-Dusty_2": "DEV",
+    "Env_HDK_CDEVC-PixelButts": "DEV",
+    "Env_HDK-SingstarDev": "DEV",
+    "Env_LBP-imagisphere": "DEV",
+    "Env_SingStar-SingStarDev": "DEV",
+    "Env_SingStar-bowzark": "DEV",
+    "Env_SCEASDFPQA-Spouts": "DEV",
+    "Env_scea989-Spounts": "DEV",
+    "Env_KungFuFactorydba-PixelButts": "DEV",
+    "Env_homecoretest-Soul 1": "DEV",
+    "Env_veemeescee-QuantumDoja2": "DEV",
+    "Env_veemeetovss-Soul 4 DECH2500": "DEV",
+    "cqa-a-Soul 3": "DEV",
+    "cqa-a-Viciousest": "DEV",
+    "cpreprod-QuantumDoja1": "DEV",
+    "cqa-e-QuantumDoja": "DEV",
+    "cqa-e-Soul 3": "DEV",
+    "ObjectCatalogue_5_SCEA_2012-11-12": "BETA",
+    "ObjectCatalogue_5_SCEE_2012-11-12": "BETA",
+}
+
+OUTPUT_FIELDS = [
+    "UUID_TXXX",
+    "ObjectId",
+    "Version",
+    "Build",
+]
+
+FIRST_INTRO_BASE_OUTPUT_FIELDS = [
+    "UUID",
+    "First Date Introduced",
+    "Last Date Removed",
+]
+
+READDED_FIELD_NAME = "Removed Date->Added Back Date"
+
+
+def get_build_from_file_path(file_path):
+    path_text = file_path.replace("\\", "/").lower()
+
+    for text, build in BUILD_MATCHES.items():
+        if text.lower() in path_text:
+            return build
+
+    return "RETAIL"
+
+
+def version_num(value):
+    try:
+        return int(str(value).strip())
+    except:
+        return -1
+
+
+def build_rank(build):
+    if build == "RETAIL":
+        return 0
+    if build == "BETA":
+        return 1
+    return 2
+
+
+def should_replace_existing(old_row, new_row):
+    old_rank = build_rank(old_row["Build"])
+    new_rank = build_rank(new_row["Build"])
+
+    if new_rank < old_rank:
+        return True
+
+    if new_rank > old_rank:
+        return False
+
+    return version_num(new_row["Version"]) > version_num(old_row["Version"])
+
+
+def clean_fieldnames(fieldnames):
+    return [
+        h.strip().replace("\ufeff", "")
+        for h in fieldnames
+    ]
+
+
+def parse_catalogue_date_from_filename(file_path):
+    filename = os.path.basename(file_path)
+
+    m = re.match(
+        r"^ObjectCatalogue_5_[^_]+_(\d{4}-\d{2}-\d{2})(?:_|-|\.|$)",
+        filename,
+        re.IGNORECASE
+    )
+
+    if m:
+        return datetime.strptime(m.group(1), "%Y-%m-%d").date()
+
+    m = re.match(
+        r"^OBJECTCATALOGUE_(\d{4}-\d{2}-\d{2})(?:_|-|\.|$)",
+        filename,
+        re.IGNORECASE
+    )
+
+    if m:
+        return datetime.strptime(m.group(1), "%Y-%m-%d").date()
+
+    return None
+
+
+def format_date(date_value):
+    if not date_value:
+        return ""
+
+    return date_value.strftime("%Y-%m-%d")
+
+
+def find_first_intro_csv_files():
+    patterns = [
+        os.path.join(TARGET_DIR, "**", "*_Combined.csv"),
+        os.path.join(TARGET_DIR, "**", "ObjectCatalogue_5_*_Objects.csv"),
+    ]
+
+    found = []
+
+    for pattern in patterns:
+        found.extend(glob.glob(pattern, recursive=True))
+
+    seen = set()
+    result = []
+
+    for path in found:
+        key = os.path.abspath(path).lower()
+        if key not in seen:
+            seen.add(key)
+            result.append(path)
+
+    return result
+
+
+def get_object_ids_from_csv(csv_file):
+    object_ids = set()
+
+    rows_read = 0
+    rows_skipped_missing_objectid = 0
+
+    with open(csv_file, "r", encoding="utf-8-sig", errors="replace", newline="") as f:
+        reader = csv.DictReader(f, delimiter=",")
+
+        if not reader.fieldnames:
+            return object_ids, rows_read, rows_skipped_missing_objectid, "no header found"
+
+        fieldnames_clean = clean_fieldnames(reader.fieldnames)
+        reader.fieldnames = fieldnames_clean
+
+        if "ObjectId" in fieldnames_clean:
+            object_id_field = "ObjectId"
+        elif len(fieldnames_clean) >= 2:
+            object_id_field = fieldnames_clean[1]
+            print(f"  WARNING: ObjectId header not found. Using COL B: {repr(object_id_field)}")
+        else:
+            return object_ids, rows_read, rows_skipped_missing_objectid, "ObjectId missing and COL B does not exist"
+
+        for row in reader:
+            rows_read += 1
+
+            uuid = row.get(object_id_field, "").strip()
+
+            if not uuid:
+                rows_skipped_missing_objectid += 1
+                continue
+
+            object_ids.add(uuid.upper())
+
+    return object_ids, rows_read, rows_skipped_missing_objectid, None
+
+
+def debug_write(debug_file, message):
+    if not DEBUG_UUID_LOG_ENABLED:
+        return
+
+    if debug_file is None:
+        return
+
+    debug_file.write(message + "\n")
+    debug_file.flush()
+
+
+def debug_uuid_event(debug_file, uuid, message):
+    if uuid.upper() not in DEBUG_UUIDS:
+        return
+
+    debug_write(debug_file, f"{uuid.upper()}\t{message}")
+
+
+def debug_snapshot_status(debug_file, current_date, current_uuids, previous_uuids, removed_now, added_now, currently_removed):
+    if not DEBUG_UUID_LOG_ENABLED:
+        return
+
+    for debug_uuid in sorted(DEBUG_UUIDS):
+        status = "PRESENT" if debug_uuid in current_uuids else "MISSING"
+
+        if debug_uuid in added_now:
+            change = "ADDED_SINCE_PREVIOUS"
+        elif debug_uuid in removed_now:
+            change = "REMOVED_SINCE_PREVIOUS"
+        elif debug_uuid in previous_uuids and debug_uuid in current_uuids:
+            change = "STILL_PRESENT"
+        elif debug_uuid not in previous_uuids and debug_uuid not in current_uuids:
+            change = "STILL_MISSING"
+        else:
+            change = "NO_CHANGE"
+
+        removed_state = ""
+
+        if debug_uuid in currently_removed:
+            removed_state = f"CURRENTLY_REMOVED_SINCE={format_date(currently_removed[debug_uuid])}"
+
+        debug_write(
+            debug_file,
+            f"{debug_uuid}\tDATE={format_date(current_date)}\tSTATUS={status}\tCHANGE={change}\t{removed_state}"
+        )
+
+
+def build_first_intro_log():
+    if os.path.exists(FIRST_INTRO_OUTPUT_FILE):
+        print("------------------------------------------------------------")
+        print("First-introduced output file already exists. Skipping uuidfirstintroduced.txt only.")
+        print(f"First-introduced output file: {FIRST_INTRO_OUTPUT_FILE}")
+        print("------------------------------------------------------------")
+        return
+
+    debug_file = None
+
+    if DEBUG_UUID_LOG_ENABLED:
+        debug_file = open(DEBUG_UUID_LOG_FILE, "w", encoding="utf-8", newline="")
+        debug_write(debug_file, "UUID\tDebug")
+        debug_write(debug_file, "------------------------------------------------------------")
+        debug_write(debug_file, "Starting UUID debug trace")
+        debug_write(debug_file, f"Target dir: {TARGET_DIR}")
+        debug_write(debug_file, f"First-introduced output file: {FIRST_INTRO_OUTPUT_FILE}")
+        debug_write(debug_file, "Debug UUIDs:")
+
+        for debug_uuid in sorted(DEBUG_UUIDS):
+            debug_write(debug_file, f"{debug_uuid}\tWATCHING")
+
+        debug_write(debug_file, "------------------------------------------------------------")
+
+    try:
+        first_intro_files = find_first_intro_csv_files()
+
+        date_to_uuids = {}
+        date_to_files = {}
+
+        files_read = 0
+        files_skipped_dev_beta = 0
+        files_skipped_no_date = 0
+        files_skipped_missing_objectid = 0
+        rows_read = 0
+        rows_skipped_missing_objectid = 0
+
+        print()
+        print("------------------------------------------------------------")
+        print("Building first-introduced / last-removed UUID date log...")
+        print(f"First-introduced output file: {FIRST_INTRO_OUTPUT_FILE}")
+
+        if DEBUG_UUID_LOG_ENABLED:
+            print(f"Debug UUID log file: {DEBUG_UUID_LOG_FILE}")
+
+        print(f"Found {len(first_intro_files)} candidate file(s).")
+        print("------------------------------------------------------------")
+        print()
+
+        for csv_file in first_intro_files:
+            build = get_build_from_file_path(csv_file)
+
+            if build != "RETAIL":
+                files_skipped_dev_beta += 1
+                debug_write(debug_file, f"SKIP_FILE_DEV_BETA\t{csv_file}\tBuild={build}")
+                continue
+
+            catalogue_date = parse_catalogue_date_from_filename(csv_file)
+
+            if catalogue_date is None:
+                files_skipped_no_date += 1
+                debug_write(debug_file, f"SKIP_FILE_NO_DATE\t{csv_file}")
+                continue
+
+            print("------------------------------------------------------------")
+            print(f"Reading snapshot file: {csv_file}")
+            print(f"Date: {format_date(catalogue_date)}")
+            print(f"Build: {build}")
+
+            debug_write(
+                debug_file,
+                f"READ_FILE\tDate={format_date(catalogue_date)}\tBuild={build}\t{csv_file}"
+            )
+
+            try:
+                object_ids, file_rows_read, file_rows_skipped, error = get_object_ids_from_csv(csv_file)
+
+                rows_read += file_rows_read
+                rows_skipped_missing_objectid += file_rows_skipped
+
+                if error:
+                    print(f"  SKIP: {error}")
+                    files_skipped_missing_objectid += 1
+                    debug_write(
+                        debug_file,
+                        f"SKIP_FILE_OBJECTID_ERROR\tDate={format_date(catalogue_date)}\tError={error}\t{csv_file}"
+                    )
+                    continue
+
+                if catalogue_date not in date_to_uuids:
+                    date_to_uuids[catalogue_date] = set()
+                    date_to_files[catalogue_date] = []
+
+                date_to_uuids[catalogue_date].update(object_ids)
+                date_to_files[catalogue_date].append(csv_file)
+
+                files_read += 1
+
+                print(f"  Rows read: {file_rows_read}")
+                print(f"  Skipped missing ObjectId: {file_rows_skipped}")
+                print(f"  UUIDs found in file: {len(object_ids)}")
+
+                for debug_uuid in sorted(DEBUG_UUIDS):
+                    if debug_uuid in object_ids:
+                        debug_write(
+                            debug_file,
+                            f"{debug_uuid}\tFOUND_IN_FILE\tDate={format_date(catalogue_date)}\t{csv_file}"
+                        )
+                    else:
+                        debug_write(
+                            debug_file,
+                            f"{debug_uuid}\tNOT_FOUND_IN_FILE\tDate={format_date(catalogue_date)}\t{csv_file}"
+                        )
+
+            except Exception as e:
+                print(f"  ERROR reading file: {e}")
+                debug_write(
+                    debug_file,
+                    f"ERROR_READING_FILE\tDate={format_date(catalogue_date)}\tError={e}\t{csv_file}"
+                )
+                continue
+
+        sorted_dates = sorted(date_to_uuids.keys())
+
+        first_intro = {}
+        last_removed = {}
+        currently_removed = {}
+        readded_events_by_uuid = {}
+
+        previous_date = None
+        previous_uuids = set()
+        ever_seen = set()
+
+        debug_write(debug_file, "------------------------------------------------------------")
+        debug_write(debug_file, "Processing snapshots in date order")
+
+        for current_date in sorted_dates:
+            current_uuids = date_to_uuids[current_date]
+
+            print("------------------------------------------------------------")
+            print(f"Processing snapshot date: {format_date(current_date)}")
+            print(f"Files combined for this date: {len(date_to_files[current_date])}")
+            print(f"UUIDs in snapshot: {len(current_uuids)}")
+
+            debug_write(
+                debug_file,
+                f"SNAPSHOT\tDate={format_date(current_date)}\tFiles={len(date_to_files[current_date])}\tUUIDs={len(current_uuids)}"
+            )
+
+            for path in date_to_files[current_date]:
+                debug_write(debug_file, f"SNAPSHOT_FILE\tDate={format_date(current_date)}\t{path}")
+
+            # First snapshot only establishes the starting set.
+            if previous_date is None:
+                for uuid in current_uuids:
+                    first_intro[uuid] = current_date
+                    ever_seen.add(uuid)
+
+                    if uuid in DEBUG_UUIDS:
+                        debug_uuid_event(
+                            debug_file,
+                            uuid,
+                            f"FIRST_SNAPSHOT_PRESENT\tFirst Date Introduced={format_date(current_date)}"
+                        )
+
+                for debug_uuid in sorted(DEBUG_UUIDS):
+                    if debug_uuid not in current_uuids:
+                        debug_uuid_event(
+                            debug_file,
+                            debug_uuid,
+                            f"FIRST_SNAPSHOT_MISSING\tDate={format_date(current_date)}"
+                        )
+
+                previous_date = current_date
+                previous_uuids = current_uuids
+                continue
+
+            removed_now = previous_uuids - current_uuids
+            added_now = current_uuids - previous_uuids
+
+            debug_snapshot_status(
+                debug_file,
+                current_date,
+                current_uuids,
+                previous_uuids,
+                removed_now,
+                added_now,
+                currently_removed
+            )
+
+            for uuid in added_now:
+                if uuid not in ever_seen:
+                    first_intro[uuid] = current_date
+                    ever_seen.add(uuid)
+
+                    debug_uuid_event(
+                        debug_file,
+                        uuid,
+                        f"FIRST_INTRODUCED\tDate={format_date(current_date)}"
+                    )
+
+                if uuid in currently_removed:
+                    removed_date = currently_removed[uuid]
+                    event_text = f"{format_date(removed_date)}->{format_date(current_date)}"
+
+                    if uuid not in readded_events_by_uuid:
+                        readded_events_by_uuid[uuid] = []
+
+                    readded_events_by_uuid[uuid].append(event_text)
+
+                    debug_uuid_event(
+                        debug_file,
+                        uuid,
+                        f"REMOVED_THEN_ADDED_BACK\t{event_text}"
+                    )
+
+                    del currently_removed[uuid]
+
+            for uuid in removed_now:
+                last_removed[uuid] = previous_date
+                currently_removed[uuid] = previous_date
+
+                debug_uuid_event(
+                    debug_file,
+                    uuid,
+                    f"REMOVED\tLast Date Removed={format_date(previous_date)}\tMissing On={format_date(current_date)}"
+                )
+
+            for debug_uuid in sorted(DEBUG_UUIDS):
+                if debug_uuid in current_uuids and debug_uuid not in added_now:
+                    debug_uuid_event(
+                        debug_file,
+                        debug_uuid,
+                        f"PRESENT_AFTER_DATE_COMPARE\tDate={format_date(current_date)}"
+                    )
+
+                if debug_uuid not in current_uuids and debug_uuid not in removed_now:
+                    debug_uuid_event(
+                        debug_file,
+                        debug_uuid,
+                        f"MISSING_AFTER_DATE_COMPARE\tDate={format_date(current_date)}"
+                    )
+
+            print(f"  Added since previous snapshot: {len(added_now)}")
+            print(f"  Removed since previous snapshot: {len(removed_now)}")
+
+            previous_date = current_date
+            previous_uuids = current_uuids
+
+        final_rows = []
+
+        for uuid in sorted(first_intro.keys()):
+            final_rows.append({
+                "UUID": uuid,
+                "First Date Introduced": format_date(first_intro[uuid]),
+                "Last Date Removed": format_date(last_removed.get(uuid)),
+                "Readded Events": readded_events_by_uuid.get(uuid, []),
+            })
+
+        max_readded_event_count = 0
+
+        for row in final_rows:
+            count = len(row["Readded Events"])
+            if count > max_readded_event_count:
+                max_readded_event_count = count
+
+        first_intro_output_fields = (
+            FIRST_INTRO_BASE_OUTPUT_FIELDS +
+            ([READDED_FIELD_NAME] * max_readded_event_count)
+        )
+
+        with open(FIRST_INTRO_OUTPUT_FILE, "w", encoding="utf-8", newline="") as f:
+            writer = csv.writer(f, delimiter="\t")
+            writer.writerow(first_intro_output_fields)
+
+            for row in final_rows:
+                output_row = [
+                    row["UUID"],
+                    row["First Date Introduced"],
+                    row["Last Date Removed"],
+                ]
+
+                readded_events = row["Readded Events"]
+
+                for event_text in readded_events:
+                    output_row.append(event_text)
+
+                while len(output_row) < len(first_intro_output_fields):
+                    output_row.append("")
+
+                writer.writerow(output_row)
+
+        debug_write(debug_file, "------------------------------------------------------------")
+        debug_write(debug_file, "Finished UUID debug trace")
+        debug_write(debug_file, f"Snapshot dates processed: {len(sorted_dates)}")
+
+        total_readded_events = 0
+        for events in readded_events_by_uuid.values():
+            total_readded_events += len(events)
+
+        debug_write(debug_file, f"Removed-then-added events written into uuidfirstintroduced.txt: {total_readded_events}")
+
+        for debug_uuid in sorted(DEBUG_UUIDS):
+            debug_write(debug_file, "------------------------------------------------------------")
+            debug_write(debug_file, f"{debug_uuid}\tFINAL")
+            debug_write(debug_file, f"{debug_uuid}\tFirst Date Introduced={format_date(first_intro.get(debug_uuid))}")
+            debug_write(debug_file, f"{debug_uuid}\tLast Date Removed={format_date(last_removed.get(debug_uuid))}")
+
+            events = readded_events_by_uuid.get(debug_uuid, [])
+
+            if events:
+                for event_text in events:
+                    debug_write(debug_file, f"{debug_uuid}\tRemoved Date->Added Back Date={event_text}")
+            else:
+                debug_write(debug_file, f"{debug_uuid}\tRemoved Date->Added Back Date=")
+
+        print("------------------------------------------------------------")
+        print("First-introduced / last-removed log done.")
+        print(f"Candidate files found: {len(first_intro_files)}")
+        print(f"Files read: {files_read}")
+        print(f"Files skipped DEV/BETA: {files_skipped_dev_beta}")
+        print(f"Files skipped missing date in filename: {files_skipped_no_date}")
+        print(f"Files skipped missing ObjectId/COL B: {files_skipped_missing_objectid}")
+        print(f"Snapshot dates processed: {len(sorted_dates)}")
+        print(f"Rows read total: {rows_read}")
+        print(f"Skipped missing ObjectId: {rows_skipped_missing_objectid}")
+        print(f"Unique UUID rows written: {len(final_rows)}")
+        print(f"Removed-then-added events written into uuidfirstintroduced.txt: {total_readded_events}")
+        print(f"Extra Removed Date->Added Back Date field count: {max_readded_event_count}")
+        print(f"First-introduced output file: {FIRST_INTRO_OUTPUT_FILE}")
+
+        if DEBUG_UUID_LOG_ENABLED:
+            print(f"Debug UUID log file: {DEBUG_UUID_LOG_FILE}")
+
+        print("------------------------------------------------------------")
+
+    finally:
+        if debug_file is not None:
+            debug_file.close()
+
+
+def main():
+    if not os.path.isdir(TARGET_DIR):
+        print("ERROR: Target directory does not exist.")
+        print(f"Target directory: {TARGET_DIR}")
+        input("")
+        return
+
+    if os.path.exists(OUTPUT_FILE):
+        print("------------------------------------------------------------")
+        print("Main output file already exists. Skipping uniqueobjects.txt only.")
+        print(f"Output file: {OUTPUT_FILE}")
+        print("Second log will still be checked.")
+        print("------------------------------------------------------------")
+
+        build_first_intro_log()
+
+        input("")
+        return
+
+    csv_files = glob.glob(
+        os.path.join(TARGET_DIR, "**", "*_Combined.csv"),
+        recursive=True
+    )
+
+    if not csv_files:
+        print("ERROR: No *_Combined.csv files found.")
+        print(f"Searched in: {TARGET_DIR}")
+        print("Second log will still be checked.")
+        build_first_intro_log()
+        input("")
+        return
+
+    print(f"Script dir: {SCRIPT_DIR}")
+    print(f"Base dir: {BASE_DIR}")
+    print(f"Target dir: {TARGET_DIR}")
+    print(f"Output file: {OUTPUT_FILE}")
+    print(f"First-introduced output file: {FIRST_INTRO_OUTPUT_FILE}")
+
+    if DEBUG_UUID_LOG_ENABLED:
+        print(f"Debug UUID log file: {DEBUG_UUID_LOG_FILE}")
+
+    print()
+    print(f"Found {len(csv_files)} *_Combined.csv file(s).")
+    print()
+
+    unique = {}
+
+    total_rows_read = 0
+    total_skipped_missing_uuid = 0
+    total_skipped_missing_fields = 0
+
+    for csv_file in csv_files:
+        build = get_build_from_file_path(csv_file)
+
+        print("------------------------------------------------------------")
+        print(f"Processing: {csv_file}")
+        print(f"Build: {build}")
+
+        rows_in_file = 0
+        skipped_in_file = 0
+
+        try:
+            with open(csv_file, "r", encoding="utf-8-sig", errors="replace", newline="") as f:
+                reader = csv.DictReader(f, delimiter=",")
+
+                if not reader.fieldnames:
+                    print("  SKIP: no header found")
+                    total_skipped_missing_fields += 1
+                    continue
+
+                fieldnames_clean = clean_fieldnames(reader.fieldnames)
+                reader.fieldnames = fieldnames_clean
+
+                required = ["UUID_TXXX", "ObjectId", "Version"]
+                missing = [field for field in required if field not in fieldnames_clean]
+
+                if missing:
+                    print(f"  SKIP: missing field(s): {', '.join(missing)}")
+                    print("  Headers found:")
+
+                    for h in fieldnames_clean:
+                        print(f"    {repr(h)}")
+
+                    total_skipped_missing_fields += 1
+                    continue
+
+                for row in reader:
+                    total_rows_read += 1
+                    rows_in_file += 1
+
+                    uuid = row.get("UUID_TXXX", "").strip()
+
+                    if not uuid:
+                        total_skipped_missing_uuid += 1
+                        skipped_in_file += 1
+                        continue
+
+                    cleaned = {
+                        "UUID_TXXX": uuid,
+                        "ObjectId": row.get("ObjectId", "").strip(),
+                        "Version": row.get("Version", "").strip(),
+                        "Build": build,
+                    }
+
+                    if uuid not in unique:
+                        unique[uuid] = cleaned
+                    else:
+                        if should_replace_existing(unique[uuid], cleaned):
+                            unique[uuid] = cleaned
+
+        except Exception as e:
+            print(f"  ERROR reading file: {e}")
+            continue
+
+        print(f"  Rows read: {rows_in_file}")
+        print(f"  Skipped missing UUID_TXXX: {skipped_in_file}")
+
+    final_rows = list(unique.values())
+
+    final_rows.sort(
+        key=lambda r: (
+            r["ObjectId"].upper(),
+            -version_num(r["Version"]),
+        )
+    )
+
+    with open(OUTPUT_FILE, "w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=OUTPUT_FIELDS, delimiter="\t")
+        writer.writeheader()
+        writer.writerows(final_rows)
+
+    build_first_intro_log()
+
+    print("------------------------------------------------------------")
+    print("Done.")
+    print(f"CSV files found: {len(csv_files)}")
+    print(f"Rows read total: {total_rows_read}")
+    print(f"Skipped missing UUID_TXXX: {total_skipped_missing_uuid}")
+    print(f"Skipped files missing fields/header: {total_skipped_missing_fields}")
+    print(f"Unique UUID_TXXX rows written: {len(final_rows)}")
+    print(f"Output file: {OUTPUT_FILE}")
+    print(f"First-introduced output file: {FIRST_INTRO_OUTPUT_FILE}")
+
+    if DEBUG_UUID_LOG_ENABLED:
+        print(f"Debug UUID log file: {DEBUG_UUID_LOG_FILE}")
+
+    print("------------------------------------------------------------")
+
+    input("")
+
+
+if __name__ == "__main__":
+    main()

OBJECTCATALOGUES/uniqueobjects.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:423a97c0bf4da26198ca2d7f1e3d105d2839a67d1fdae1098b3a166e33bb9bd9
+size 10062823

OBJECTS-MAPPED/scripts/archive.org-cli.py

@@ -0,0 +1,550 @@
+import internetarchive
+import os
+import re
+
+ITEM_ID = "PSHomeMappedObjects"
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+FILE_LIST = os.path.join(SCRIPT_DIR, "log.txt")
+SOURCE_DIR = r"Q:\PSHOME-INT\PSHomeCacheDepot\OBJECTS-MAPPED\ARCHIVE"
+
+# SET THIS:
+# "upload" = upload ZIP files from SOURCE_DIR folders 0-9/A-F, starting at START_FOLDER, and skip files already on archive.org
+# "delete" = delete ZIP files listed in log.txt; names can include .zip or no extension
+MODE = "upload"
+
+START_FOLDER = "0"
+PAUSE_AFTER_EACH_FOLDER = True
+BATCH_UPLOAD_SIZE = 1000
+
+FOLDER_ORDER = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]
+UPLOAD_EXTS = {".zip"}
+
+
+def pause_exit():
+    input("\nPress Enter to exit...")
+
+
+def is_allowed_upload_file(name):
+    return os.path.splitext(name)[1].lower() in UPLOAD_EXTS
+
+
+def clean_name(line):
+    text = line.strip().strip('"').strip("'").replace("\\", "/")
+    return text.split("/")[-1].strip()
+
+
+def normalize_delete_zip_name(line):
+    name = clean_name(line)
+
+    if not name:
+        return None
+
+    root, ext = os.path.splitext(name)
+
+    if ext == "":
+        return name + ".zip"
+
+    if ext.lower() == ".zip":
+        return name
+
+    return None
+
+
+def normalize_folder(folder):
+    return folder.strip().upper()
+
+
+def get_start_folders():
+    start = normalize_folder(START_FOLDER)
+
+    if start not in FOLDER_ORDER:
+        raise ValueError(f"Invalid START_FOLDER: {START_FOLDER}")
+
+    start_index = FOLDER_ORDER.index(start)
+    return FOLDER_ORDER[start_index:]
+
+
+def get_folder_from_zip_name(name):
+    base = normalize_delete_zip_name(name)
+
+    if not base:
+        raise ValueError(f"Invalid zip filename: {name}")
+
+    first = base[:1].upper()
+
+    if first not in FOLDER_ORDER:
+        raise ValueError(f"Cannot determine archive folder from filename: {name}")
+
+    return first
+
+
+def remote_name_from_zip_name(name):
+    base = normalize_delete_zip_name(name)
+
+    if not base:
+        raise ValueError(f"Invalid zip filename: {name}")
+
+    folder = get_folder_from_zip_name(base)
+    return f"{folder}/{base}"
+
+
+def remote_name_from_local(source_dir, local_path):
+    rel = os.path.relpath(local_path, source_dir)
+    return rel.replace("\\", "/")
+
+
+def scan_upload_folder(source_dir, folder):
+    folder_path = os.path.join(source_dir, folder)
+
+    if not os.path.isdir(folder_path):
+        print(f"[WARN] Missing local folder: {folder_path}")
+        return []
+
+    entries = []
+    seen_remote = set()
+
+    for root, dirs, files in os.walk(folder_path):
+        dirs.sort()
+        files.sort()
+
+        for file_name in files:
+            if not is_allowed_upload_file(file_name):
+                continue
+
+            local_path = os.path.join(root, file_name)
+            remote_name = remote_name_from_local(source_dir, local_path)
+            low = remote_name.lower()
+
+            if low in seen_remote:
+                print(f"[WARN] Duplicate remote path skipped: {remote_name}")
+                continue
+
+            seen_remote.add(low)
+            entries.append((remote_name, local_path))
+
+    return entries
+
+
+def load_file_list(path):
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Missing file: {path}")
+
+    with open(path, "r", encoding="utf-8", errors="ignore") as f:
+        raw = [line.strip() for line in f if line.strip()]
+
+    names = []
+    seen = set()
+
+    for line in raw:
+        name = normalize_delete_zip_name(line)
+
+        if not name:
+            continue
+
+        low = name.lower()
+
+        if low not in seen:
+            seen.add(low)
+            names.append(name)
+
+    return names
+
+
+def list_item_files(item_id):
+    item = internetarchive.get_item(item_id)
+    out = []
+
+    for f in item.files:
+        name = f.get("name")
+        if name:
+            out.append(name)
+
+    return out
+
+
+def chunks(items, size):
+    for i in range(0, len(items), size):
+        yield items[i:i + size]
+
+
+def upload_batch(item_id, batch_entries, remote_set, batch_num, batch_total):
+    uploaded = []
+    skipped = []
+    failed = []
+
+    batch_dict = {}
+
+    for remote_name, local_path in batch_entries:
+        remote_low = remote_name.lower()
+
+        if remote_low in remote_set:
+            print(f"[SKIP] Already uploaded: {remote_name}")
+            skipped.append(remote_name)
+            continue
+
+        if not os.path.exists(local_path):
+            print(f"[ERROR] Missing local file: {local_path}")
+            failed.append(remote_name)
+            continue
+
+        batch_dict[remote_name] = local_path
+
+    if not batch_dict:
+        return uploaded, skipped, failed
+
+    print(f"[BATCH {batch_num}/{batch_total}] Uploading {len(batch_dict)} file(s)...")
+
+    for remote_name, local_path in batch_dict.items():
+        print(f"  {remote_name}")
+        print(f"    {local_path}")
+
+    print()
+
+    try:
+        result = internetarchive.upload(
+            item_id,
+            batch_dict,
+            verbose=True
+        )
+
+        ok = True
+
+        if result is not None:
+            try:
+                for r in result:
+                    if hasattr(r, "status_code") and r.status_code not in (200, 201):
+                        ok = False
+            except TypeError:
+                pass
+
+        if ok:
+            for remote_name in batch_dict:
+                print(f"[OK] Uploaded: {remote_name}")
+                uploaded.append(remote_name)
+                remote_set.add(remote_name.lower())
+        else:
+            for remote_name in batch_dict:
+                print(f"[ERROR] Batch upload may have failed: {remote_name}")
+                failed.append(remote_name)
+
+    except Exception as e:
+        print(f"[ERROR] Batch upload failed: {e}")
+        print("[INFO] Marking this batch as failed. Rerun the script later and already-uploaded files will be skipped.")
+
+        for remote_name in batch_dict:
+            failed.append(remote_name)
+
+    print()
+
+    return uploaded, skipped, failed
+
+
+def upload_entries(item_id, upload_entries, remote_set):
+    uploaded = []
+    skipped = []
+    failed = []
+
+    upload_entries = list(upload_entries)
+    batch_list = list(chunks(upload_entries, BATCH_UPLOAD_SIZE))
+    batch_total = len(batch_list)
+
+    for batch_num, batch_entries in enumerate(batch_list, start=1):
+        batch_uploaded, batch_skipped, batch_failed = upload_batch(
+            item_id,
+            batch_entries,
+            remote_set,
+            batch_num,
+            batch_total
+        )
+
+        uploaded.extend(batch_uploaded)
+        skipped.extend(batch_skipped)
+        failed.extend(batch_failed)
+
+    return uploaded, skipped, failed
+
+
+def find_delete_targets(all_remote_files, file_names):
+    remote_set = {x.lower() for x in all_remote_files}
+    matches = []
+    missing = []
+    seen = set()
+
+    for name in file_names:
+        try:
+            remote_name = remote_name_from_zip_name(name)
+        except Exception as e:
+            print(f"[WARN] {e}")
+            missing.append(name)
+            continue
+
+        low = remote_name.lower()
+
+        if low in remote_set:
+            if low not in seen:
+                seen.add(low)
+                matches.append(remote_name)
+        else:
+            missing.append(remote_name)
+
+    return matches, missing
+
+
+def delete_remote_files(item_id, remote_names):
+    deleted = []
+    failed = []
+
+    for name in remote_names:
+        print(f"Deleting main file: {name}")
+
+        try:
+            internetarchive.delete(
+                item_id,
+                files=name,
+                cascade_delete=False,
+                verbose=True
+            )
+            print(f"[OK] Deleted: {name}")
+            deleted.append(name)
+        except Exception as e:
+            print(f"[ERROR] Failed deleting {name}: {e}")
+            failed.append(name)
+
+        print()
+
+    return deleted, failed
+
+
+def find_matching_history_backups(all_remote_files, target_names):
+    target_set = set()
+
+    for name in target_names:
+        try:
+            target_set.add(remote_name_from_zip_name(name).lower())
+        except Exception:
+            pass
+
+    matches = []
+    pattern = re.compile(r"^history/files/(.+?)\.~\d+~$", re.IGNORECASE)
+
+    for remote_name in all_remote_files:
+        m = pattern.match(remote_name)
+
+        if not m:
+            continue
+
+        backed_up_name = m.group(1).replace("\\", "/").lower()
+
+        if backed_up_name in target_set:
+            matches.append(remote_name)
+
+    return matches
+
+
+def delete_backup_files(item_id, backup_names):
+    deleted = []
+    failed = []
+
+    for remote_name in backup_names:
+        print(f"Deleting backup file: {remote_name}")
+
+        try:
+            internetarchive.delete(
+                item_id,
+                files=remote_name,
+                cascade_delete=False,
+                verbose=True
+            )
+            print(f"[OK] Deleted backup: {remote_name}")
+            deleted.append(remote_name)
+        except Exception as e:
+            print(f"[ERROR] Failed deleting backup {remote_name}: {e}")
+            failed.append(remote_name)
+
+        print()
+
+    return deleted, failed
+
+
+def write_log(path, lines):
+    with open(path, "w", encoding="utf-8", newline="") as f:
+        for line in lines:
+            f.write(str(line) + "\n")
+
+
+def run_upload_mode(item_id, source_dir):
+    print("[MODE] UPLOAD")
+    print(f"[INFO] Source folder: {source_dir}")
+    print(f"[INFO] Start folder: {START_FOLDER}")
+    print(f"[INFO] Batch upload size: {BATCH_UPLOAD_SIZE}")
+    print()
+
+    try:
+        folders = get_start_folders()
+    except Exception as e:
+        print(f"[FATAL] {e}")
+        pause_exit()
+        return
+
+    print("[INFO] Checking archive.org item for existing files...")
+
+    try:
+        remote_files = list_item_files(item_id)
+        remote_set = {x.lower() for x in remote_files}
+        print(f"[OK] Remote item has {len(remote_files)} file(s).")
+    except Exception as e:
+        print(f"[FATAL] Could not list archive.org item files: {e}")
+        pause_exit()
+        return
+
+    print()
+
+    all_uploaded = []
+    all_skipped = []
+    all_failed = []
+
+    uploaded_log = os.path.join(SCRIPT_DIR, "_uploaded_ok.txt")
+    skipped_log = os.path.join(SCRIPT_DIR, "_upload_skipped_existing.txt")
+    failed_log = os.path.join(SCRIPT_DIR, "_upload_failed.txt")
+
+    for folder in folders:
+        print("========================================")
+        print(f"[FOLDER] {folder}")
+        print("========================================")
+
+        upload_list = scan_upload_folder(source_dir, folder)
+
+        print(f"[OK] Found {len(upload_list)} zip file(s) in folder {folder}.")
+        print()
+
+        uploaded, skipped, failed = upload_entries(item_id, upload_list, remote_set)
+
+        all_uploaded.extend(uploaded)
+        all_skipped.extend(skipped)
+        all_failed.extend(failed)
+
+        write_log(uploaded_log, all_uploaded)
+        write_log(skipped_log, all_skipped)
+        write_log(failed_log, all_failed)
+
+        print(f"========== FOLDER {folder} SUMMARY ==========")
+        print(f"Found:             {len(upload_list)}")
+        print(f"Uploaded:          {len(uploaded)}")
+        print(f"Skipped existing:  {len(skipped)}")
+        print(f"Failed:            {len(failed)}")
+        print()
+
+        if PAUSE_AFTER_EACH_FOLDER:
+            input(f"[PAUSE] Finished folder {folder}. Press Enter to continue, or close this window to stop...")
+
+        print()
+
+    print("========== FINAL SUMMARY ==========")
+    print(f"Uploaded:          {len(all_uploaded)}")
+    print(f"Skipped existing:  {len(all_skipped)}")
+    print(f"Failed:            {len(all_failed)}")
+    print()
+    print(f"Uploaded log: {uploaded_log}")
+    print(f"Skipped log:  {skipped_log}")
+    print(f"Failed log:   {failed_log}")
+
+    if all_failed:
+        print("\nFailed uploads:")
+        for name in all_failed:
+            print(name)
+
+
+def run_delete_mode(item_id, file_names):
+    print("[MODE] DELETE")
+    print(f"[OK] Loaded {len(file_names)} zip file name(s) from {FILE_LIST}")
+    print()
+
+    print("[INFO] Scanning item files...")
+
+    try:
+        all_files = list_item_files(item_id)
+    except Exception as e:
+        print(f"[ERROR] Could not scan item files: {e}")
+        pause_exit()
+        return
+
+    delete_targets, missing_targets = find_delete_targets(all_files, file_names)
+    backup_matches = find_matching_history_backups(all_files, file_names)
+
+    print(f"[INFO] Found {len(delete_targets)} matching main file(s).")
+    print(f"[INFO] Missing {len(missing_targets)} requested file(s).")
+    print(f"[INFO] Found {len(backup_matches)} matching backup file(s).")
+    print()
+
+    delete_target_log = os.path.join(SCRIPT_DIR, "_delete_resolved_targets.txt")
+    missing_target_log = os.path.join(SCRIPT_DIR, "_delete_missing_targets.txt")
+
+    write_log(delete_target_log, delete_targets)
+    write_log(missing_target_log, missing_targets)
+
+    deleted_main, delete_failed = delete_remote_files(item_id, delete_targets)
+
+    if backup_matches:
+        deleted_backups, backup_failed = delete_backup_files(item_id, backup_matches)
+    else:
+        deleted_backups = []
+        backup_failed = []
+
+    print("========== SUMMARY ==========")
+    print(f"Files requested:   {len(file_names)}")
+    print(f"Main matched:      {len(delete_targets)}")
+    print(f"Main missing:      {len(missing_targets)}")
+    print(f"Main deleted:      {len(deleted_main)}")
+    print(f"Main delete fail:  {len(delete_failed)}")
+    print(f"Backups matched:   {len(backup_matches)}")
+    print(f"Backups deleted:   {len(deleted_backups)}")
+    print(f"Backup del fail:   {len(backup_failed)}")
+    print()
+    print(f"Resolved delete target log: {delete_target_log}")
+    print(f"Missing delete target log:  {missing_target_log}")
+
+    if delete_failed:
+        print("\nFailed main deletes:")
+        for name in delete_failed:
+            print(name)
+
+    if backup_failed:
+        print("\nFailed backup deletes:")
+        for name in backup_failed:
+            print(name)
+
+
+def main():
+    mode = MODE.strip().lower()
+
+    if mode == "upload":
+        run_upload_mode(ITEM_ID, SOURCE_DIR)
+
+    elif mode == "delete":
+        try:
+            file_names = load_file_list(FILE_LIST)
+        except Exception as e:
+            print(f"[FATAL] {e}")
+            pause_exit()
+            return
+
+        if not file_names:
+            print(f"[WARN] No zip entries found in: {FILE_LIST}")
+            pause_exit()
+            return
+
+        run_delete_mode(ITEM_ID, file_names)
+
+    else:
+        print(f"[FATAL] Invalid MODE: {MODE}")
+        print('Use MODE = "upload" or MODE = "delete"')
+        pause_exit()
+        return
+
+    print("\nDone.")
+    pause_exit()
+
+
+if __name__ == "__main__":
+    main()

OBJECTS-MAPPED/scripts/log_files.py

@@ -1,17 +1,24 @@
 import os
 
+
 def log_zip_files(root_folder, output_file):
-    with open(output_file, "w") as f:
+    with open(output_file, "w", encoding="utf-8") as f:
         for dirpath, dirnames, filenames in os.walk(root_folder):
             for file in filenames:
                 if file.lower().endswith(".zip"):
-                    # Remove the .zip extension and write only the file name
                     file_name_without_ext, _ = os.path.splitext(file)
                     f.write(file_name_without_ext + "\n")
 
+
 if __name__ == "__main__":
-    # Set the directory you want to start searching from; here it's the current directory
-    root_folder = "."
-    output_file = "log.txt"
+    script_folder = os.path.dirname(os.path.abspath(__file__))
+    objects_mapped_folder = os.path.dirname(script_folder)
+
+    root_folder = objects_mapped_folder
+    output_file = os.path.join(objects_mapped_folder, "log.txt")
+
     log_zip_files(root_folder, output_file)
-    print(f"ZIP file names without extension logged in '{output_file}'.")
+
+    print(f"ZIP file names without extension logged in:")
+    print(output_file)
+    input("\nPress Enter to exit...")

OBJECTS-MAPPED/scripts/move_files.py

@@ -1,28 +1,51 @@
 import os
 import shutil
 
-# Automatically get the directory where the script is located
+
+def pause_exit():
+    input("\nPress Enter to exit...")
+
+
 source_dir = os.path.dirname(os.path.abspath(__file__))
-archive_dir = os.path.join(source_dir, "TMP")
 
-# Define valid hex digits in uppercase
 hex_digits = "0123456789ABCDEF"
 
-# Create subfolders (0-9 and A-F) inside the ARCHIVE folder if they don't exist
-for digit in hex_digits:
-    folder_path = os.path.join(archive_dir, digit)
+moved_count = 0
+skipped_count = 0
+
+for filename in os.listdir(source_dir):
+    source_file = os.path.join(source_dir, filename)
+
+    if not os.path.isfile(source_file):
+        continue
+
+    if not filename.lower().endswith(".zip"):
+        continue
+
+    first_digit = filename[0].upper()
+
+    if first_digit not in hex_digits:
+        print(f"Skipping {filename}: first character '{filename[0]}' is not 0-9 or A-F.")
+        skipped_count += 1
+        continue
+
+    folder_path = os.path.join(source_dir, first_digit)
+    dest_file = os.path.join(folder_path, filename)
+
     os.makedirs(folder_path, exist_ok=True)
 
-# Iterate over each file in the ARCHIVE folder
-for filename in os.listdir(archive_dir):
-    # Process only zip files that match the expected naming pattern
-    if filename.endswith(".zip"):
-        # Convert the first character of the filename to uppercase
-        first_digit = filename[0].upper()
-        if first_digit in hex_digits:
-            source_file = os.path.join(archive_dir, filename)
-            dest_file = os.path.join(archive_dir, first_digit, filename)
-            print(f"Moving {filename} to folder {first_digit}/")
-            shutil.move(source_file, dest_file)
-        else:
-            print(f"Skipping file {filename}: first character '{filename[0]}' is not a valid hex digit.")
+    if os.path.exists(dest_file):
+        print(f"Skipping {filename}: already exists in {first_digit}\\")
+        skipped_count += 1
+        continue
+
+    print(f"Moving {filename} to {first_digit}\\")
+    shutil.move(source_file, dest_file)
+    moved_count += 1
+
+print()
+print(f"Done.")
+print(f"Moved: {moved_count}")
+print(f"Skipped: {skipped_count}")
+
+pause_exit()

OBJECTS/OBJECT_QUERY.xlsm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8611dbee345b8f0ddc12236391c84cf954f37f9a14899703e2a535314823e9b8
+size 158175360

OBJECTS/OBJECT_QUERY.xlsx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3bbd05c96b7d52eb20a2a588768f81682c9f5896fac74cae3e4db8f3d5c76f26
-size 164070600
+oid sha256:c650f28e1f0c83604ba5551f9c36db6c1cfb1019b775ac19cb0becb9599fbef7
+size 155166378

OBJECTS/uniqueobjects.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5bb91b9a0aae5649cc3930eb897ae7eb27aad81a12fc5d0d46d5e963b2fdc073
+size 15577866

ODC/scripts/move_files.py

@@ -1,52 +1,75 @@
 import os
 import shutil
 
-# Automatically get the directory where the script is located
+
+def pause_exit():
+    input("\nPress Enter to exit...")
+
+
 source_dir = os.path.dirname(os.path.abspath(__file__))
-odcs_decrypted_dir = os.path.join(source_dir, "TMP")
 
-# Define valid hex digits (uppercase)
 hex_digits = "0123456789ABCDEF"
 
-# Define valid prefixes and create their directories with subfolders for hex digits
-prefixes = ["live", "live2"]
-
-for prefix in prefixes:
-    prefix_dir = os.path.join(odcs_decrypted_dir, prefix)
-    os.makedirs(prefix_dir, exist_ok=True)
-    # Create subfolders 0-9 and A-F within each prefix folder
-    for digit in hex_digits:
-        subfolder = os.path.join(prefix_dir, digit)
-        os.makedirs(subfolder, exist_ok=True)
-
-# Iterate over each .odc file in the ODCsDecrypted folder
-for filename in os.listdir(odcs_decrypted_dir):
-    if filename.endswith(".odc"):
-        # Check if the file name contains a '$' and starts with one of the valid prefixes
-        if "$" in filename:
-            # Check for live2$ first, then live$
-            if filename.startswith("live2$"):
-                prefix = "live2"
-            elif filename.startswith("live$"):
-                prefix = "live"
-            else:
-                print(f"Skipping file {filename}: does not start with a valid prefix.")
-                continue
-
-            # Split the filename by '$' to extract the UUID part
-            parts = filename.split("$", 1)
-            if len(parts) != 2:
-                print(f"Skipping file {filename}: unexpected filename format.")
-                continue
-            uuid_part = parts[1]
-            # Get the first character of the UUID and convert to uppercase
-            first_digit = uuid_part[0].upper()
-            if first_digit in hex_digits:
-                source_file = os.path.join(odcs_decrypted_dir, filename)
-                dest_file = os.path.join(odcs_decrypted_dir, prefix, first_digit, filename)
-                print(f"Moving {filename} to {prefix}/{first_digit}/")
-                shutil.move(source_file, dest_file)
-            else:
-                print(f"Skipping file {filename}: first character '{uuid_part[0]}' is not a valid hex digit.")
-        else:
-            print(f"Skipping file {filename}: missing '$' in filename.")
+moved_count = 0
+skipped_count = 0
+
+for filename in os.listdir(source_dir):
+    source_file = os.path.join(source_dir, filename)
+
+    if not os.path.isfile(source_file):
+        continue
+
+    if not filename.lower().endswith(".odc"):
+        continue
+
+    lower_name = filename.lower()
+
+    if "$" not in filename:
+        print(f"Skipping {filename}: missing '$' in filename.")
+        skipped_count += 1
+        continue
+
+    if lower_name.startswith("live2$"):
+        prefix = "live2"
+    elif lower_name.startswith("live$"):
+        prefix = "live"
+    else:
+        print(f"Skipping {filename}: does not start with live$ or live2$.")
+        skipped_count += 1
+        continue
+
+    parts = filename.split("$", 1)
+
+    if len(parts) != 2 or not parts[1]:
+        print(f"Skipping {filename}: unexpected filename format.")
+        skipped_count += 1
+        continue
+
+    uuid_part = parts[1]
+    first_digit = uuid_part[0].upper()
+
+    if first_digit not in hex_digits:
+        print(f"Skipping {filename}: first UUID character '{uuid_part[0]}' is not 0-9 or A-F.")
+        skipped_count += 1
+        continue
+
+    folder_path = os.path.join(source_dir, prefix, first_digit)
+    dest_file = os.path.join(folder_path, filename)
+
+    os.makedirs(folder_path, exist_ok=True)
+
+    if os.path.exists(dest_file):
+        print(f"Skipping {filename}: already exists in {prefix}\\{first_digit}\\")
+        skipped_count += 1
+        continue
+
+    print(f"Moving {filename} to {prefix}\\{first_digit}\\")
+    shutil.move(source_file, dest_file)
+    moved_count += 1
+
+print()
+print("Done.")
+print(f"Moved: {moved_count}")
+print(f"Skipped: {skipped_count}")
+
+pause_exit()

SCENE VERSION XMLS/scripts/VERS_XML_PARSER.py

@@ -3,16 +3,21 @@ import sys
 import hashlib
 from pathlib import Path
 
+
+def pause_exit():
+    input("\nPress Enter to exit...")
+
+
 def clean_string(s):
-    """Remove 'http://' and ':10010' from a string."""
     return s.replace('http://', '').replace(':10010', '')
 
+
 def extract_value(pattern, content):
     match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
     return match.group(1) if match else ""
 
+
 def calculate_sha1(file_path):
-    """Calculate SHA1 hash of a file and return uppercase hex digest."""
     try:
         sha1 = hashlib.sha1()
         with open(file_path, 'rb') as f:
@@ -23,8 +28,11 @@ def calculate_sha1(file_path):
         print(f"Error calculating SHA1 for {file_path}: {e}", file=sys.stderr)
         return "ERROR"
 
+
 def main():
-    base_dir = Path.cwd()
+    script_dir = Path(__file__).resolve().parent
+    base_dir = script_dir.parent
+
     xml_dir = base_dir / "XML"
     log_path = base_dir / "log_VERSXMLS.txt"
 
@@ -35,10 +43,11 @@ def main():
     xml_files = list(xml_dir.rglob("*.XML"))
 
     with log_path.open("w", encoding="utf-8") as log:
-        # Add header
         log.write("CDNPATH\tSCENEVERS\tCHECKVER\tSHA1\n")
+
         for xml_path in xml_files:
             counter += 1
+
             try:
                 content = xml_path.read_text(encoding="utf-8")
             except Exception as e:
@@ -53,5 +62,9 @@ def main():
             log.write(f"{cdnpath}\t{scenevers}\t{checkver}\t{sha1_hash}\n")
             print(f"{counter} LOGGED {xml_path.name}")
 
+
 if __name__ == "__main__":
-    main()
+    try:
+        main()
+    finally:
+        pause_exit()

SCENELISTS/scripts/scenelist_parser.py

@@ -1,6 +1,11 @@
 import os
 import xml.etree.ElementTree as ET
 
+
+def pause_exit():
+    input("\nPress Enter to exit...")
+
+
 def parse_xml_file(file_path, subfolder_name=""):
     tree = ET.parse(file_path)
     root = tree.getroot()
@@ -9,44 +14,35 @@ def parse_xml_file(file_path, subfolder_name=""):
     def process_scene(scene, region_name=""):
         scene_data = []
         file_name = os.path.splitext(os.path.basename(file_path))[0]
-        scene_data.append(file_name)  # file name
+        scene_data.append(file_name)
 
-        # Add subfolder name
         scene_data.append(subfolder_name)
 
-        # Extract 'ID'/'Name'
         id_or_name_key = 'ID' if 'ID' in scene.attrib else 'Name'
         id_or_name_value = scene.get(id_or_name_key, '')
-        
-        # Unique ID logic based on 'desc'
+
         desc = scene.get('desc', '')
         desc_parts = desc.split('/')
         unique_id = f"{id_or_name_value}${desc_parts[-1]}" if desc_parts else ""
         alt_name = f"{desc_parts[0]}${desc_parts[-1]}" if desc_parts and desc_parts[0] != id_or_name_value else ""
 
-        # Add 'unique id', 'alt name', and 'region' to the scene data
         scene_data.extend([unique_id, alt_name, region_name])
 
-        # Add 'ID'/'Name'
         scene_data.extend([id_or_name_key, id_or_name_value] if id_or_name_value else ["", ""])
 
-        # Process other attributes before 'config'
         pre_config_attributes = ["Type", "host", "desc"]
         for attr in pre_config_attributes:
             value = scene.get(attr, '')
             scene_data.extend([attr, value] if value else ["", ""])
 
-        # Process 'config' attribute
         config_value = scene.get('config', '')
         scene_data.extend(["config", config_value] if config_value else ["", ""])
 
-        # Extract 'SceneID'/'ChannelID'
         scene_id_or_channel_id_key = 'SceneID' if 'SceneID' in scene.attrib else 'ChannelID'
         scene_id_or_channel_id_value = scene.get(scene_id_or_channel_id_key, '')
         scene_data.extend([scene_id_or_channel_id_key, scene_id_or_channel_id_value] if scene_id_or_channel_id_value else ["", ""])
 
-        # Process attributes after 'config'
-        post_config_attributes = ["Group", "KEYWORDS", "access", "capacity", 
+        post_config_attributes = ["Group", "KEYWORDS", "access", "capacity",
                                   "softcap", "flags", "HOMEUID", "version", "sha1"]
         for attr in post_config_attributes:
             value = scene.get(attr, '')
@@ -64,30 +60,27 @@ def parse_xml_file(file_path, subfolder_name=""):
 
     return scenes_info
 
+
 def write_log_file(target_folder, log_file_path):
     headers = ["file name", "env", "unique id", "alt name", "region", "ID/Name attribute", "ID/Name value"]
     pre_config_attributes = ["Type", "host", "desc"]
-    post_config_attributes = ["Group", "KEYWORDS", "access", "capacity", 
+    post_config_attributes = ["Group", "KEYWORDS", "access", "capacity",
                               "softcap", "flags", "HOMEUID", "version", "sha1"]
 
-    # Add headers for attributes before 'config'
     for attr in pre_config_attributes:
         headers.extend([f"{attr} attribute", f"{attr} value"])
-    
-    # Add headers for 'config' and 'SceneID/ChannelID'
+
     headers.extend(["config attribute", "config value", "SceneID/ChannelID attribute", "SceneID/ChannelID value"])
 
-    # Add headers for attributes after 'config'
     for attr in post_config_attributes:
         headers.extend([f"{attr} attribute", f"{attr} value"])
 
-    all_rows = []  # store all scene_info rows
+    all_rows = []
 
-    # Recursively search DEC folder
     for root_dir, _, files in os.walk(target_folder):
         subfolder_name = os.path.relpath(root_dir, target_folder)
         if subfolder_name == ".":
-            subfolder_name = ""  # root folder case
+            subfolder_name = ""
 
         # --- Skip DEC\GDCDEMO0.41 (and its subfolders) ---
         if subfolder_name.replace("\\", "/").startswith("GDCDEMO0.41"):
@@ -100,7 +93,6 @@ def write_log_file(target_folder, log_file_path):
                 scenes_info = parse_xml_file(file_path, subfolder_name)
                 all_rows.extend(scenes_info)
 
-    # Sort: unique id (index 2) Z?A, then file name (index 0) Z?A
     all_rows.sort(key=lambda r: (r[2].lower(), r[0].lower()), reverse=True)
 
     with open(log_file_path, 'w', encoding='utf-8') as log_file:
@@ -108,12 +100,25 @@ def write_log_file(target_folder, log_file_path):
         for scene_info in all_rows:
             log_file.write('\t'.join(map(str, scene_info)) + '\n')
 
+
 def main():
-    current_dir = os.getcwd()  # Gets the current working directory.
-    target_folder = os.path.join(current_dir, "DEC")
-    log_file_path = os.path.join(current_dir, "SCENELIST.TXT")
+    script_folder = os.path.dirname(os.path.abspath(__file__))
+    scenelists_folder = os.path.dirname(script_folder)
+
+    target_folder = os.path.join(scenelists_folder, "DEC")
+    log_file_path = os.path.join(scenelists_folder, "SCENELIST.TXT")
+
+    if os.path.exists(log_file_path):
+        print(f"Skipped. File already exists:")
+        print(log_file_path)
+        return
+
     write_log_file(target_folder, log_file_path)
     print(f"Log file generated at: {log_file_path}")
 
+
 if __name__ == "__main__":
-    main()
+    try:
+        main()
+    finally:
+        pause_exit()

SCENES-MAPPED/Mapped_Scenes_Query.xlsm

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0d1873499ef2324c2cdcd347909fbc012e0b9863ad41a3fb8604fe164e9c11cb
-size 99162242
+oid sha256:504888c631f5a1a5a68312f70074347a065feacfc58a0084730b09f58e43ef18
+size 99166567

SCENES-MAPPED/Mapped_Scenes_Query.xlsx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6123b994416024ca762d95a12e7669821c824820976304ac698acac4035d18d8
-size 94913522
+oid sha256:d163a2bfb2c0ebeb63798283b36251da84c7823f10dddeaffa5a2a6702627308
+size 94919144