Merge pull request #19 from apple1417/master

apple1417 · web-flow · commit 03e2f59a3987 · 2025-01-03T11:46:17.000+13:00
exodus fixups
diff --git a/changelog.md b/changelog.md
@@ -4,6 +4,9 @@
 
 ### Legacy Compat v1.1
 - Fixed that some legacy mods would not auto-enable properly.
+- Added a compat handler for object names - they didn't use to include the number. This previously
+  caused crash when trying to load Exodus.
+- Added a fixup to Constructor, and Constructor-based mods, to handle the new mod folder location.
 
 ### [pyunrealsdk v1.5.2](https://github.com/bl-sdk/pyunrealsdk/blob/master/changelog.md#v152)
 This version has no `pyunrealsdk` changes, it simply pulled in a new version of `unrealsdk`.
diff --git a/src/legacy_compat/__init__.py b/src/legacy_compat/__init__.py
@@ -89,22 +89,19 @@ def add_compat_module(name: str, module: ModuleType) -> None:  # pyright: ignore
     ENABLED = False  # pyright: ignore[reportConstantRedefinition]
 else:
     import ctypes
-    import inspect
     import sys
     import warnings
-    from collections.abc import Iterator, Sequence
+    from collections.abc import Iterator
     from contextlib import contextmanager
     from functools import wraps
-    from importlib.machinery import ModuleSpec, SourceFileLoader
-    from importlib.util import spec_from_file_location
-    from pathlib import Path
 
     from unrealsdk.hooks import prevent_hooking_direct_calls
 
     from mods_base import MODS_DIR
 
     from . import ModMenu
     from . import unrealsdk as old_unrealsdk
+    from .meta_path_finder import LegacyCompatMetaPathFinder
 
     base_mod.components.append(base_mod.ComponentInfo("Legacy SDK Compat", __version__))
 
@@ -161,65 +158,6 @@ def add_compat_module(name: str, module: ModuleType) -> None:  # pyright: ignore
         "Mods.UserFeedback.ctypes": ctypes,
     }
 
-    # On top of this, we do actually need a full import hook to redirect other mod-specific imports
-
-    class LegacyCompatMetaPathFinder:
-        @staticmethod
-        def get_importing_file() -> Path:
-            """
-            Gets the file which triggered the in progress import.
-
-            Returns:
-                The importing file.
-            """
-            # Skip the frame for this function and find_spec below
-            for frame in inspect.stack()[2:]:
-                # Then skip everything in the import machinery
-                if "importlib" in frame.filename:
-                    continue
-                return Path(frame.filename)
-            raise RuntimeError
-
-        @classmethod
-        def find_spec(
-            cls,
-            fullname: str,
-            path: Sequence[str] | None = None,  # noqa: ARG003
-            target: ModuleType | None = None,  # noqa: ARG003
-        ) -> ModuleSpec | None:
-            # EridiumLib adds it's dist folder with a path relative to the executable - fix that
-            # We also have some problems with it's copy of requests, so redirect that to our copy
-            if fullname == "requests" and cls.get_importing_file().parent.name == "EridiumLib":
-                # Can't easily load the real requests, but turns out all we actually need is a get
-                # method, which is allowed to just throw
-                # Using a custom loader to inject it rather than loading from file, since the latter
-                # doesn't work properly if we're packaged inside a .sdkmod
-                class FakeRequestsLoader(SourceFileLoader):
-                    def get_data(self, path: str) -> bytes:  # noqa: ARG002
-                        return (
-                            b"def get(url: str, timeout: int) -> str:  # noqa: D103\n"
-                            b"    raise NotImplementedError"
-                        )
-
-                return spec_from_file_location(
-                    "Mods.EridiumLib.fake_dist.requests",
-                    "<fake location>",
-                    loader=FakeRequestsLoader(
-                        "Mods.EridiumLib.fake_dist.requests",
-                        "<fake location>",
-                    ),
-                )
-            if (
-                fullname == "semver"
-                and (mod_folder := cls.get_importing_file().parent).name == "EridiumLib"
-            ):
-                return spec_from_file_location(
-                    "Mods.EridiumLib.fake_dist.semver",
-                    mod_folder / "dist" / "semver.py",
-                )
-
-            return None
-
     @contextmanager
     def import_compat_handler() -> Iterator[None]:
         """Context manager to add the import compatibility."""
diff --git a/src/legacy_compat/meta_path_finder.py b/src/legacy_compat/meta_path_finder.py
@@ -0,0 +1,154 @@
+import inspect
+import re
+from collections.abc import Callable, Sequence
+from importlib.abc import FileLoader, SourceLoader
+from importlib.machinery import ModuleSpec, PathFinder, SourceFileLoader
+from importlib.util import spec_from_file_location
+from pathlib import Path
+from types import ModuleType
+
+# While just messing with `Mod.__path__` is enough for most most mods, there are a few we need to do
+# more advanced import hooking on.
+
+
+class StringSourceLoader(SourceFileLoader):
+    source: bytes
+
+    def __init__(self, fullname: str, path: str, source: bytes) -> None:
+        super().__init__(fullname, path)
+        self.source = source
+
+    def get_data(self, path: str) -> bytes:  # noqa: ARG002, D102
+        return self.source
+
+
+def spec_from_string(fullname: str, source: bytes) -> ModuleSpec | None:
+    """
+    Creates a module spec from a hardcoded string.
+
+    Args:
+        fullname: The fully resolved module name.
+        source: The source code.
+    """
+    return spec_from_file_location(
+        fullname,
+        "<fake location>",
+        loader=StringSourceLoader(fullname, "<fake location>", source),
+    )
+
+
+# Inheriting straight from SourceFileLoade causes some other machinery to expect bytecode?
+class ReplacementSourceLoader(FileLoader, SourceLoader):  # type: ignore
+    type Pattern = tuple[bytes | re.Pattern[bytes], bytes | Callable[[re.Match[bytes]], bytes]]
+
+    replacements: Sequence[Pattern]
+
+    def __init__(self, fullname: str, path: str, replacements: Sequence[Pattern]) -> None:
+        super().__init__(fullname, path)
+        self.replacements = replacements
+
+    def get_data(self, path: str) -> bytes:  # noqa: D102
+        data = Path(path).read_bytes()
+        for pattern, replacement in self.replacements:
+            data = re.sub(pattern, replacement, data)
+        return data
+
+
+def spec_with_replacements(
+    fullname: str,
+    path: Sequence[str] | None = None,
+    target: ModuleType | None = None,
+    *replacements: ReplacementSourceLoader.Pattern,
+) -> ModuleSpec | None:
+    """
+    Creates a module spec based on the existing module, but applying a set of regex replacements.
+
+    Args:
+        fullname: The fully resolved module name, copied from the original call.
+        path: The paths to search, copied from the original call.
+        target: The target copied from the original call.
+        *replacements: Tuples of a regex pattern and it's replacement.
+    """
+    original_spec = PathFinder.find_spec(fullname, path, target)
+    if original_spec is None or not original_spec.has_location or original_spec.origin is None:
+        return None
+
+    return spec_from_file_location(
+        fullname,
+        original_spec.origin,
+        loader=ReplacementSourceLoader(fullname, original_spec.origin, replacements),
+    )
+
+
+class LegacyCompatMetaPathFinder:
+    @staticmethod
+    def get_importing_file() -> Path:
+        """
+        Gets the file which triggered the in progress import.
+
+        Returns:
+            The importing file.
+        """
+        # Skip the frame for this function and find_spec below
+        for frame in inspect.stack()[2:]:
+            # Then skip everything in the import machinery
+            if "importlib" in frame.filename:
+                continue
+            return Path(frame.filename)
+        raise RuntimeError
+
+    @classmethod
+    def find_spec(  # noqa: D102
+        cls,
+        fullname: str,
+        path: Sequence[str] | None = None,
+        target: ModuleType | None = None,
+    ) -> ModuleSpec | None:
+        importing_file = cls.get_importing_file()
+
+        match importing_file.parent.name, fullname:
+            # EridiumLib adds it's dist folder with a path relative to the executable - fix that
+            case "EridiumLib", "semver":
+                return spec_from_file_location(
+                    "Mods.EridiumLib.fake_dist.semver",
+                    importing_file.parent / "dist" / "semver.py",
+                )
+
+            # Something about trying to load a requests build from 6 major versions ago completely
+            # breaks, we can't easily get it to load.
+            # However, it turns out all EridiumLib needs is a get method, which is allowed to just
+            # throw.
+            case "EridiumLib", "requests":
+                return spec_from_string(
+                    "Mods.EridiumLib.fake_dist.requests",
+                    (
+                        b"def get(url: str, timeout: int) -> str:  # noqa: D103\n"
+                        b"    raise NotImplementedError"
+                    ),
+                )
+
+            # Constructor has a bad bit of logic for getting the relative file path to execute.
+            # Since we moved the mods folder, it breaks. Replace it with some proper logic.
+            case (
+                ("Constructor", "Mods.Constructor.hotfix_manager")
+                | ("Exodus", "Mods.Exodus.hotfix_manager")
+                | ("ExodusTPS", "Mods.ExodusTPS.hotfix_manager")
+                | ("Snowbound", "Mods.Snowbound.hotfix_manager")
+            ):
+                return spec_with_replacements(
+                    fullname,
+                    path,
+                    target,
+                    # Import on one line just to avoid changing line numbers
+                    (b"import os", b"import os, sys"),
+                    (
+                        rb'( +)exec_path = str\(file\)\.split\("Binaries\\+", 1\)\[1\]([\r\n]+)'
+                        rb'( +)bl2tools.console_command\("exec " \+ exec_path, False\)([\r\n]+)',
+                        rb"\1exec_path = os.path.relpath(file,"
+                        rb' os.path.join(sys.executable, "..", ".."))\2'
+                        rb"\3bl2tools.console_command(f'exec \"{exec_path}\"', False)\4",
+                    ),
+                )
+
+            case _, _:
+                return None
diff --git a/src/legacy_compat/unrealsdk/__init__.py b/src/legacy_compat/unrealsdk/__init__.py
@@ -1,6 +1,7 @@
 # ruff: noqa: N802, N803, D102, D103, N999
 
 import inspect
+import re
 from collections.abc import Callable, Iterator, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass
@@ -263,10 +264,13 @@ def KeepAlive(obj: UObject, /) -> None:
 - The legacy sdk returned None instead of throwing an attribute error when a field didn't exist.
 - The legacy sdk had interface properties return an FScriptInterface struct, but since you only ever
   accessed the object, the new sdk just returns it directly. We need to return the struct instead.
+- In the legacy sdk, name properties did not include the number when converted to a string, which we
+  need to strip out.
 
 UObject:
 - The `ObjectFlags` field on objects used to be split into the upper and lower 32 bits (B and A
   respectively), new sdk returns a single 64 bit int. Return a proxy object instead.
+- The `Name` field is also a name property, so needs have the suffix stripped as above.
 - In the legacy sdk the __repr__ of objects was just kind of wrong, but we need to replicate it.
 
 BoundFunction:
@@ -340,6 +344,21 @@ def _convert_struct_tuple_if_required(prop: UProperty, value: Any) -> Any:
     return value
 
 
+_RE_NAME_SUFFIX = re.compile(r"^(.+)_\d+$")
+
+
+def _strip_name_property_suffix(name: str) -> str:
+    """
+    Tries to strip the numeric suffix from a name property.
+
+    Args:
+        name: The input name.
+    Returns:
+        The stripped name.
+    """
+    return match.group(1) if (match := _RE_NAME_SUFFIX.match(name)) else name
+
+
 @wraps(UObject.__getattr__)
 def _uobject_getattr(self: UObject, name: str) -> Any:
     try:
@@ -349,10 +368,13 @@ def _uobject_getattr(self: UObject, name: str) -> Any:
 
     value = self._get_field(prop)
 
-    if isinstance(prop, UInterfaceProperty):
-        return FScriptInterface(value)
-
-    return value
+    match prop:
+        case UInterfaceProperty():
+            return FScriptInterface(value)
+        case UNameProperty():
+            return _strip_name_property_suffix(value)
+        case _:
+            return value
 
 
 @dataclass
@@ -384,12 +406,16 @@ def __int__(self) -> int:
         return _default_object_getattribute(self._obj, "ObjectFlags")
 
 
-# Because we want to overwrite an exiting field, we have to use getattribute over getattr
+# Because we want to overwrite exiting fields, we have to use getattribute over getattr
 @wraps(UObject.__getattribute__)
 def _uobject_getattribute(self: UObject, name: str) -> Any:
-    if name == "ObjectFlags":
-        return _ObjectFlagsProxy(self)
-    return _default_object_getattribute(self, name)
+    match name:
+        case "ObjectFlags":
+            return _ObjectFlagsProxy(self)
+        case "Name":
+            return _strip_name_property_suffix(_default_object_getattribute(self, "Name"))
+        case _:
+            return _default_object_getattribute(self, name)
 
 
 @wraps(UObject.__setattr__)
@@ -422,10 +448,13 @@ def _struct_getattr(self: WrappedStruct, name: str) -> Any:
 
     value = self._get_field(prop)
 
-    if isinstance(prop, UInterfaceProperty):
-        return FScriptInterface(value)
-
-    return value
+    match prop:
+        case UInterfaceProperty():
+            return FScriptInterface(value)
+        case UNameProperty():
+            return _strip_name_property_suffix(value)
+        case _:
+            return value
 
 
 @wraps(WrappedStruct.__setattr__)
@@ -443,14 +472,23 @@ def _struct_setattr(self: WrappedStruct, name: str, value: Any) -> None:
 def _array_getitem[T](self: WrappedArray[T], idx: int | slice) -> T | list[T]:
     value = _default_array_getitem(self, idx)
 
-    if not isinstance(self._type, UInterfaceProperty):
-        return value
+    match self._type:
+        case UInterfaceProperty():
+            if isinstance(idx, slice):
+                val_seq: Sequence[T] = value  # type: ignore
+                return [FScriptInterface(x) for x in val_seq]  # type: ignore
 
-    if isinstance(idx, slice):
-        val_seq: Sequence[T] = value  # type: ignore
-        return [FScriptInterface(x) for x in val_seq]  # type: ignore
+            return FScriptInterface(value)  # type: ignore
+        case UNameProperty():
+            if isinstance(idx, slice):
+                val_seq: Sequence[T] = value  # type: ignore
+                return [_strip_name_property_suffix(x) for x in val_seq]  # type: ignore
 
-    return FScriptInterface(value)  # type: ignore
+            return _strip_name_property_suffix(value)  # type: ignore
+
+            return _strip_name_property_suffix(value)
+        case _:
+            return value
 
 
 @wraps(WrappedArray[Any].__setitem__)
