refactor(core): remove extraneous methods from FolderConfig

Directories should be created/checked for existence when needed.
Using `Path` objects directly is usually cleaner than using methods.

feat(core): dynamically set attrs in `FolderConfig`

Author: djsigmann

core/backup_manager.py

@@ -2,17 +2,19 @@
 import shutil
 
 from core.folder_setup import folder_setup
+from core.util.file import delete
 
 log = logging.getLogger()
 
 
 def prepare_working_copy() -> bool:
     try:
-        folder_setup.cleanup_temp_folders()
-        folder_setup.create_required_folders()
+        delete(folder_setup.temp_dir, not_exist_ok=True)
 
         backup_particles_dir = folder_setup.backup_dir / "particles"
         particle_dest_dir = folder_setup.temp_to_be_referenced_dir
+        backup_particles_dir.mkdir(parents=True, exist_ok=True)
+        particle_dest_dir.mkdir(parents=True, exist_ok=True)
 
         for pcf_file in backup_particles_dir.glob("*.pcf"):
             shutil.copy2(pcf_file, particle_dest_dir / pcf_file.name)

core/folder_setup.py

@@ -1,27 +1,22 @@
-import os
-import shutil
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
-
-from valve_parsers import PCFFile
 
 # INFO: This file just allows package maintainers to set whether this application should act as if it is a portable installation.
 # They can easily modify this file and set these values, e.g.
 # `printf '%s\n' 'portable = False' >core/are_we_portable.py`
 # This will make the application use paths outside the installation location.
 from core.are_we_portable import portable
 from core.constants import PROGRAM_AUTHOR, PROGRAM_NAME
-from core.handlers.pcf_handler import get_parent_elements
 
 
 @dataclass
 class FolderConfig:
     # configuration class for managing folder paths
-    install_dir = Path(os.path.dirname(os.path.abspath(__file__))).parent  # INFO: I'm not too sure if this can break or not, oh well
+    install_dir = Path(__file__).resolve().parent.parent
+    data_dir =   install_dir / 'data'
+
     portable = portable  # make sure it is accessible via self.portable
 
-    # TODO: allow windows users to use non-portable installs (would allow us to remove this entire platform check)
     if portable:
         # default portable values
         project_dir = install_dir
@@ -33,81 +28,41 @@ class FolderConfig:
         project_dir = Path(platformdirs.user_data_dir(PROGRAM_NAME, PROGRAM_AUTHOR))
         settings_dir = Path(platformdirs.user_config_dir(PROGRAM_NAME, PROGRAM_AUTHOR))
 
-    base_default_pcf: Optional[PCFFile] = field(default=None)
-    base_default_parents: Optional[set[str]] = field(default=None)
-
-    # main folder names
-    _backup_folder = "backup"
-    _mods_folder = "mods"
-
-    # mods subdir
-    _mods_particles_folder = "particles"
-    _mods_addons_folder = "addons"
-
-    # temp and it's nested folders (to be cleared every run)
-    _temp_folder = "temp"
-    _temp_to_be_processed_folder = "to_be_processed"
-    _temp_to_be_referenced_folder = "to_be_referenced"
-    _temp_to_be_patched_folder = "to_be_patched"
-    _temp_to_be_vpk_folder = "to_be_vpk"
+    __deps = {
+        'project_dir': {
+            'backup_dir' :    lambda self: self.project_dir / 'backup',
+            'mods_dir' :      lambda self: self.project_dir / 'mods',
+            'temp_dir' :      lambda self: self.project_dir / 'temp',
+        },
+        'mods_dir' : {
+            'particles_dir' : lambda self: self.mods_dir / 'particles',
+            'addons_dir' :    lambda self: self.mods_dir / 'addons',
+        },
+        'temp_dir' : {
+            'temp_download_dir' :         lambda self: self.temp_dir / 'download',
+            'temp_to_be_processed_dir' :  lambda self: self.temp_dir / 'to_be_processed',
+            'temp_to_be_referenced_dir' : lambda self: self.temp_dir / 'to_be_referenced',
+            'temp_to_be_patched_dir' :    lambda self: self.temp_dir / 'to_be_patched',
+            'temp_to_be_vpk_dir' :        lambda self: self.temp_dir / 'to_be_vpk',
+        },
+    }
 
     def __post_init__(self):
-        self.backup_dir = self.project_dir / self._backup_folder
-        self.data_dir = self.install_dir / "data"
-
-        self.mods_dir = self.project_dir / self._mods_folder
-        self.particles_dir = self.mods_dir / self._mods_particles_folder
-        self.addons_dir = self.mods_dir / self._mods_addons_folder
-
-        self.temp_dir = self.project_dir / self._temp_folder
-        self.temp_download_dir = self.temp_dir  / 'download'
-        self.temp_to_be_processed_dir = self.temp_dir / self._temp_to_be_processed_folder
-        self.temp_to_be_referenced_dir = self.temp_dir / self._temp_to_be_referenced_folder
-        self.temp_to_be_patched_dir = self.temp_dir / self._temp_to_be_patched_folder
-        self.temp_to_be_vpk_dir = self.temp_dir / self._temp_to_be_vpk_folder
-
-    def create_required_folders(self) -> None:
-        folders = [
-            self.mods_dir,
-            self.addons_dir,
-            self.particles_dir,
-
-            self.temp_dir,
-            self.temp_to_be_processed_dir,
-            self.temp_to_be_referenced_dir,
-            self.temp_to_be_patched_dir,
-            self.temp_to_be_vpk_dir
-        ]
-
-        for folder in folders:
-            folder.mkdir(parents=True, exist_ok=True)
-
-    def initialize_pcf(self):
-        if self.temp_to_be_referenced_dir.exists():
-            default_base_path = self.temp_to_be_referenced_dir / "disguise.pcf"
-            if default_base_path.exists():
-                self.base_default_pcf = PCFFile(default_base_path).decode()
-                self.base_default_parents = get_parent_elements(self.base_default_pcf)
-
-    def cleanup_temp_folders(self) -> None:
-        # anything put in temp/ will be gone !!!!!
-        if self.temp_dir.exists():
-            shutil.rmtree(self.temp_dir)
-            self.base_default_pcf = None
-            self.base_default_parents = None
-
-    def get_temp_path(self, filename: str) -> Path:
-        return self.temp_dir / filename
-
-    def get_output_path(self, filename: str) -> Path:
-        return self.temp_to_be_processed_dir / filename
+        for dep, props in self.__deps.items():
+            for attr, setter in props.items():
+                super().__setattr__(attr, setter(self))
 
-    def get_backup_path(self, filename: str) -> Path:
-        return self.backup_dir / filename
+    def __setattr__(self, attr, value):
+        _super = super()
+        _super.__setattr__(attr, value)
 
-    def get_game_files_path(self, filename: str) -> Path:
-        return self.temp_to_be_referenced_dir / filename
+        if attr in self.__deps:
+            for _attr, setter in self.__deps[attr].items():
+                _super.__setattr__(_attr, setter(self))
+        else:
+            for dep, props in tuple(self.__deps.items()):
+                if attr in props:
+                    del props[attr]
 
 
-# create a default instance for import
-folder_setup = FolderConfig()
+folder_setup = FolderConfig() # create a default instance for import

core/handlers/file_handler.py

@@ -69,7 +69,8 @@ def process_file(self, file_name: str, content) -> bool | None:
             full_path = file_name
 
         # create temp file for processing in working directory
-        temp_path = folder_setup.get_temp_path(f"temp_{Path(file_name).name}")
+        temp_path = folder_setup.temp_dir / f"temp_{Path(file_name).name}"
+        temp_path.parent.mkdir(parents=True, exist_ok=True)
 
         try:
             # get original file info

core/operations/advanced_particle_merger.py

@@ -92,8 +92,11 @@ def preprocess_vpk(self, vpk_path: Path) -> None:
         for particle in particles_filter:
             for particle_file_target, elements_to_extract, source_pcf in (
                     rebuild_particle_files(particle, self.particle_map)):
-                output_path = folder_setup.get_output_path(
-                    f"{len(self.vpk_groups[vpk_folder_name][particle_file_target])}_{particle_file_target}")
+                output_path = (
+                    folder_setup.temp_to_be_processed_dir
+                    / f"{len(self.vpk_groups[vpk_folder_name][particle_file_target])}_{particle_file_target}"
+                )
+                output_path.parent.mkdir(parents=True, exist_ok=True)
                 extract_elements(source_pcf, elements_to_extract).encode(output_path)
                 self.vpk_groups[vpk_folder_name][particle_file_target].append(output_path)
 
@@ -121,6 +124,7 @@ def process_vpk_group(self, vpk_name: str, out_dir: Path) -> None:
 
             if elements_we_still_need:
                 game_file_path = folder_setup.temp_to_be_referenced_dir / particle_group
+                game_file_path.parent.mkdir(parents=True, exist_ok=True) # INFO: technically not necessary, but PCFFile does not check if `input_file` exists, let alone its parent dir
                 game_file_in = PCFFile(game_file_path).decode()
                 game_elements = extract_elements(game_file_in, elements_we_still_need)
 
@@ -143,5 +147,5 @@ def process_vpk_group(self, vpk_name: str, out_dir: Path) -> None:
                 actual_particles.parent.mkdir(parents=True, exist_ok=True)
                 result.encode(actual_particles)
 
-        for file in folder_setup.temp_to_be_processed_dir.iterdir():
+        for file in folder_setup.temp_to_be_processed_dir.glob('*'):
             file.unlink()

core/operations/file_processors.py

@@ -3,6 +3,8 @@
 
 from valve_parsers import PCFFile, VPKFile
 
+from core.handlers.pcf_handler import get_parent_elements
+
 log = logging.getLogger()
 
 
@@ -80,6 +82,16 @@ def should_process_file(file_path: str) -> bool:
     return any(path in path_lower for path in target_paths) and path_lower.endswith('.vmt')
 
 
+def initialize_pcf(dir: Path) -> tuple[PCFFile, set[str]]:
+    default_base_path = dir / 'disguise.pcf'
+
+    if not default_base_path.exists():
+        raise FileNotFoundError(f"[Errno 2] No such file or directory: {default_base_path}")
+
+    default_base_pcf = PCFFile(default_base_path).decode()
+    return default_base_pcf, get_parent_elements(default_base_pcf)
+
+
 get_val = [
     [34, 36, 105, 103, 110, 111, 114, 101, 122, 34, 9, 34, 49, 34],
     [34, 36, 105, 103, 110, 111, 114, 101, 122, 34, 9, 49],

core/particle_splits.py

@@ -14,6 +14,8 @@ def migrate_old_particle_files():
     mods_to_migrate = []
     mods_missing_source = []
 
+    folder_setup.particles_dir.mkdir(parents=True, exist_ok=True)
+
     # check each mod for old format files
     for mod_dir in folder_setup.particles_dir.iterdir():
         if not mod_dir.is_dir():

core/quickprecache/quick_precache.py

@@ -157,6 +157,7 @@ def make_precache_sub_list_file(self, filename: str, data: str) -> bool:
         # create a QC file and compile it with StudioMDL
         try:
             # create a temporary file
+            folder_setup.temp_dir.mkdir(parents=True, exist_ok=True)
             temp_file = tempfile.NamedTemporaryFile(
                 mode='w',
                 suffix='.qc',
@@ -189,6 +190,7 @@ def make_precache_list_file(self) -> bool:
         # create the main precache.qc file that includes all subfiles
         try:
             # create the main QC file
+            folder_setup.temp_dir.mkdir(parents=True, exist_ok=True)
             temp_file = tempfile.NamedTemporaryFile(
                 mode='w',
                 suffix='.qc',

gui/addon_manager.py

@@ -19,6 +19,7 @@ def __init__(self, settings_manager):
 
     def load_addons(self, addons_list):
         addons_dir = folder_setup.addons_dir
+        addons_dir.mkdir(parents=True, exist_ok=True)
         # block the signal so the addons list doesn't clear in the app_settings.json
         addons_list.blockSignals(True)
         addons_list.clear()
@@ -95,6 +96,7 @@ def load_addon_info(addon_name: str) -> dict:
     def scan_addon_contents(self):
         addon_metadata = self.settings_manager.get_addon_metadata() or {}
         addons_dir = folder_setup.addons_dir
+        addons_dir.mkdir(parents=True, exist_ok=True)
         addons = [d for d in addons_dir.iterdir() if d.is_dir()]
         processed = 0
         new_or_updated = 0

gui/drag_and_drop.py

@@ -128,6 +128,7 @@ def get_mod_particle_files():
     all_particles = set()
 
     # scan directories
+    folder_setup.particles_dir.mkdir(parents=True, exist_ok=True)
     for vpk_dir in folder_setup.particles_dir.iterdir():
         if vpk_dir.is_dir():
             particle_dir = vpk_dir / "actual_particles"
@@ -210,6 +211,7 @@ def apply_particle_selections(self):
                         source_file = source_particles_dir / (particle_file + ".pcf")
                         if source_file.exists():
                             # copy particle file to to_be_patched
+                            folder_setup.temp_to_be_patched_dir.mkdir(parents=True, exist_ok=True)
                             shutil.copy2(source_file, folder_setup.temp_to_be_patched_dir / (particle_file + ".pcf"))
                             # get particle file mats from attrib
                             pcf = PCFFile(source_file).decode()
@@ -267,6 +269,7 @@ def apply_particle_selections(self):
                     merged = pcf_parts[0]
 
                 output_path = folder_setup.temp_to_be_patched_dir / original_file
+                output_path.parent.mkdir(parents=True, exist_ok=True)
                 merged.encode(output_path)
 
                 for split_file in split_files_in_temp:
@@ -586,7 +589,6 @@ def dropEvent(self, event):
 
         self.setProperty('dragOver', False)
         self.style().polish(self)
-        folder_setup.create_required_folders()
 
         # collect all dropped items
         dropped_items = []

gui/interface.py

@@ -17,15 +17,19 @@
 )
 from core.folder_setup import folder_setup
 from core.handlers.file_handler import FileHandler, copy_config_files, generate_config
+from core.handlers.paint_handler import disable_paints, enable_paints
 from core.handlers.pcf_handler import (
     check_parents,
     restore_particle_files,
     update_materials,
 )
-from core.handlers.paint_handler import disable_paints, enable_paints
 from core.handlers.skybox_handler import handle_skybox_mods, restore_skybox_files
 from core.handlers.sound_handler import SoundHandler
-from core.operations.file_processors import game_type, get_from_custom_dir
+from core.operations.file_processors import (
+    game_type,
+    get_from_custom_dir,
+    initialize_pcf,
+)
 from core.operations.for_the_love_of_god_add_vmts_to_your_mods import (
     generate_missing_vmt_files,
 )
@@ -79,7 +83,7 @@ def install(self, tf_path: str, selected_addons: List[str], mod_drop_zone=None):
         try:
             working_vpk_path = Path(tf_path) / get_vpk_name(tf_path)
             file_handler = FileHandler(str(working_vpk_path))
-            folder_setup.initialize_pcf()
+            base_default_pcf, base_default_parents  = initialize_pcf(folder_setup.temp_to_be_referenced_dir)
             self.update_progress(0, "Installing addons...")
 
             total_files = 0
@@ -236,6 +240,7 @@ def install(self, tf_path: str, selected_addons: List[str], mod_drop_zone=None):
                     if not target_path.exists():
                         # copy from game_files if not in
                         source_path = folder_setup.temp_to_be_referenced_dir / duplicate_effect
+                        target_path.parent.mkdir(parents=True, exist_ok=True)
                         if source_path.exists():
                             extract_elements(PCFFile(source_path).decode(),
                                              load_particle_system_map(folder_setup.data_dir / 'particle_system_map.json')
@@ -262,12 +267,11 @@ def install(self, tf_path: str, selected_addons: List[str], mod_drop_zone=None):
                     base_name = pcf_file.name
 
                     mod_pcf = PCFFile(pcf_file).decode()
-
-                    if base_name != folder_setup.base_default_pcf.input_file.name and check_parents(mod_pcf, folder_setup.base_default_parents):
+                    if base_name != base_default_pcf.input_file.name and check_parents(mod_pcf, base_default_parents):
                         continue
 
-                    if base_name == folder_setup.base_default_pcf.input_file.name:
-                        mod_pcf = update_materials(folder_setup.base_default_pcf, mod_pcf)
+                    if base_name == base_default_pcf.input_file.name:
+                        mod_pcf = update_materials(base_default_pcf, mod_pcf)
 
                     # process the mod PCF
                     processed_pcf = remove_duplicate_elements(mod_pcf)
@@ -354,6 +358,7 @@ def install(self, tf_path: str, selected_addons: List[str], mod_drop_zone=None):
                 split_size = 2 ** 31
                 vpk_base_path = custom_dir / CUSTOM_VPK_NAME.replace('.vpk', '')
 
+                custom_content_dir.mkdir(parents=True, exist_ok=True) # INFO: technically not necessary, but VPKFile does not check if `source_dir` exists
                 if not VPKFile.create(str(custom_content_dir), str(vpk_base_path), split_size):
                     raise Exception("Failed to create custom VPK")