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()