refactor: use pathlib instead of os.path for cross-platform path handling

Author: PaulWinterstein

src/vipat_cli_scripts/generate_all.py

@@ -1,5 +1,5 @@
 import argparse
-import os
+from pathlib import Path
 
 from vipat_cli_scripts.generate_driver_models import main as generate_driver_models
 from vipat_cli_scripts.version_utils import ROOT_DIR, list_available_schema_versions, load_module
@@ -10,9 +10,9 @@
 
 def main():
     args = parser.parse_args()
-    schema_file = os.path.join(ROOT_DIR, "apps", "inventory", "model", "driver_schema", f"{args.version}.json")
+    schema_file = Path(ROOT_DIR) / "apps" / "inventory" / "model" / "driver_schema" / f"{args.version}.json"
 
-    if not os.path.exists(schema_file):
+    if not schema_file.exists():
         print(
             f"VideoIPath version {args.version} is currently not supported. Please create an issue on https://github.com/SWR-MoIP/VideoIPath-Automation-Tool/issues to request support for this version or use one of the following versions:"
         )
@@ -24,7 +24,8 @@ def main():
     generate_driver_models(schema_file)
 
     # Note: Module should be loaded after generate_driver_models to ensure it imports the correct version of the drivers module
-    generate_overloads_mod = load_module("generate_overloads", "src/vipat_cli_scripts/generate_overloads.py")
+    generate_overloads_path = ROOT_DIR.parent / "vipat_cli_scripts" / "generate_overloads.py"
+    generate_overloads_mod = load_module("generate_overloads", generate_overloads_path)
     generate_overloads = generate_overloads_mod.main
     generate_overloads()
 

src/vipat_cli_scripts/generate_driver_models.py

@@ -1,30 +1,33 @@
 import argparse
 import json
-import os
+from pathlib import Path
 
 from vipat_cli_scripts.version_utils import ROOT_DIR, list_available_schema_versions, load_module
 
 DEFAULT_VERSION = "2024.4.12"
-DEFAULT_SCHEMA_FILE = os.path.join(ROOT_DIR, "apps", "inventory", "model", "driver_schema", f"{DEFAULT_VERSION}.json")
-DEFAULT_OUTPUT_FILE = os.path.join(ROOT_DIR, "apps", "inventory", "model", "drivers.py")
+DEFAULT_SCHEMA_FILE = Path(ROOT_DIR) / "apps" / "inventory" / "model" / "driver_schema" / f"{DEFAULT_VERSION}.json"
+DEFAULT_OUTPUT_FILE = Path(ROOT_DIR) / "apps" / "inventory" / "model" / "drivers.py"
+
 
 parser = argparse.ArgumentParser(description="Generate Pydantic models from driver schema")
 parser.add_argument(
     "schema_file",
     nargs="?",
+    type=Path,
     default=DEFAULT_SCHEMA_FILE,
     help="Path to the driver schema JSON file",
 )
 parser.add_argument(
     "output_file",
     nargs="?",
+    type=Path,
     default=DEFAULT_OUTPUT_FILE,
     help="Path where the generated Python file will be saved",
 )
 
 
 def _generate_driver_model(driver_schema: dict) -> str:
-    pmb_module = load_module("pydantic_model_builder", os.path.join(ROOT_DIR, "utils", "pydantic_model_builder.py"))
+    pmb_module = load_module("pydantic_model_builder", Path(ROOT_DIR) / "utils" / "pydantic_model_builder.py")
     PydanticModelBuilder = pmb_module.PydanticModelBuilder
     PydanticModelField = pmb_module.PydanticModelField
 
@@ -119,11 +122,9 @@ def format_value(value: str | int | float) -> str:
     return field["_schema"]["type"], None
 
 
-def main(
-    schema_file: str = DEFAULT_SCHEMA_FILE,
-    output_file: str = DEFAULT_OUTPUT_FILE,
-):
-    schema = json.load(open(schema_file))
+def main(schema_file: Path = DEFAULT_SCHEMA_FILE, output_file: Path = DEFAULT_OUTPUT_FILE):
+    with open(schema_file, "r", encoding="utf-8") as f:
+        schema = json.load(f)
 
     drivers = schema["data"]["status"]["system"]["drivers"]["_items"]
     driver_models = "\n\n".join([_generate_driver_model(driver) for driver in drivers])
@@ -135,12 +136,12 @@ def main(
 
 # Notes:
 # - The name of the custom settings model follows the naming convention: CustomSettings_<driver_organization>_<driver_name>_<driver_version> => "." and "-" are replaced by "_"!
-# - Schema {schema_file.split("/")[-1]} is used as reference to define the custom settings model!
+# - Schema {Path(schema_file).name} is used as reference to define the custom settings model!
 # - The "driver_id" attribute is necessary for the discriminator, which is used to determine the correct model for the custom settings in DeviceConfiguration!
 # - The "alias" attribute is used to map the attribute to the correct key (with driver organization & name) in the JSON payload for the API!
 # - "DriverLiteral" is used to provide a list of all possible drivers in the IDEs IntelliSense!
 
-SELECTED_SCHEMA_VERSION = "{schema_file.split("/")[-1].split(".json")[0]}"
+SELECTED_SCHEMA_VERSION = "{Path(schema_file).stem}"
 AVAILABLE_SCHEMA_VERSIONS = {list_available_schema_versions()}
 
 class DriverCustomSettings(ABC, BaseModel, validate_assignment=True): ...
@@ -163,7 +164,7 @@ class DriverCustomSettings(ABC, BaseModel, validate_assignment=True): ...
 """
     print("Drivers generated successfully!")
 
-    with open(output_file, "w") as f:
+    with open(output_file, "w", encoding="utf-8") as f:
         f.write(code)
         print(f"Updated {output_file}")
 

src/vipat_cli_scripts/generate_overloads.py

@@ -1,18 +1,10 @@
-import os
 import re
-from pathlib import Path
 from typing import Callable
 
-from vipat_cli_scripts.version_utils import load_module
+from vipat_cli_scripts.version_utils import ROOT_DIR, load_module
 
-current_file = Path(__file__).resolve()
-ROOT_DIR = current_file.parent.parent / "videoipath_automation_tool"
-
-
-DRIVERS_MODULE = load_module(
-    "drivers_module",
-    os.path.join(ROOT_DIR, "apps", "inventory", "model", "drivers.py"),
-)
+drivers_path = ROOT_DIR / "apps" / "inventory" / "model" / "drivers.py"
+DRIVERS_MODULE = load_module("drivers_module", drivers_path)
 DRIVER_ID_TO_CUSTOM_SETTINGS = DRIVERS_MODULE.DRIVER_ID_TO_CUSTOM_SETTINGS
 
 
@@ -41,21 +33,24 @@ def generate_get_device_overloads() -> str:
 
 
 def generate_overloads(method: str, generate_overloads: Callable) -> None:
-    FILE_PATH = os.path.join(ROOT_DIR, "apps", "inventory", "app", f"{method}.py")
+    file_path = ROOT_DIR / "apps" / "inventory" / "app" / f"{method}.py"
+
+    if not file_path.exists():
+        print(f"File not found: {file_path} ❌")
+        return
 
-    with open(FILE_PATH, "r") as f:
-        content = f.read()
+    content = file_path.read_text()
 
     overload_pattern = re.compile(
         r"# --------------------------------\n    #  Start Auto-Generated Overloads\n    # --------------------------------\n(.*?)# ------------------------------\n    #  End Auto-Generated Overloads\n    # ------------------------------",
         re.DOTALL,
     )
 
     if not re.findall(overload_pattern, content):
-        print(f"No overload section found in {FILE_PATH} ❌")
+        print(f"No overload section found in {file_path} ❌")
         return
 
-    with open(FILE_PATH, "w") as f:
+    with open(file_path, "w") as f:
         f.write(
             re.sub(
                 overload_pattern,
@@ -64,7 +59,7 @@ def generate_overloads(method: str, generate_overloads: Callable) -> None:
             )
         )
 
-    print(f"Updated overloads in {FILE_PATH} ✅")
+    print(f"Updated overloads in {file_path} ✅")
 
 
 def main():

src/vipat_cli_scripts/version_utils.py

@@ -1,7 +1,7 @@
 import importlib.util
-import os
 from pathlib import Path
 from types import ModuleType
+from typing import Union
 
 from videoipath_automation_tool.apps.inventory.model.drivers import SELECTED_SCHEMA_VERSION
 
@@ -10,9 +10,9 @@
 
 
 def list_available_schema_versions() -> list[str]:
-    schema_dir = os.path.join(ROOT_DIR, "apps", "inventory", "model", "driver_schema")
+    schema_dir = ROOT_DIR / "apps" / "inventory" / "model" / "driver_schema"
     return sorted(
-        [f.split(".json")[0] for f in os.listdir(schema_dir) if f.endswith(".json")],
+        [f.stem for f in Path(schema_dir).glob("*.json")],
         key=lambda x: tuple(map(int, x.split("."))),
     )
 
@@ -30,14 +30,15 @@ def get_videoipath_version():
     return None
 
 
-def load_module(module_name: str, file_path: str) -> ModuleType:
-    spec = importlib.util.spec_from_file_location(
-        module_name,
-        file_path,
-    )
+def load_module(module_name: str, file_path: Union[str, Path]) -> ModuleType:
+    file_path = Path(file_path).resolve()
+
+    if not file_path.exists():
+        raise FileNotFoundError(f"Module file not found: {file_path}")
 
+    spec = importlib.util.spec_from_file_location(module_name, str(file_path))
     if spec is None or spec.loader is None:
-        raise ValueError("Failed to load drivers module")
+        raise ImportError(f"Failed to load module: {module_name} from {file_path}")
 
     module = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(module)