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