Lint Python code and add standard linter settings (#84)

* keybind improvements

add `IsRebindable` and `IsHidden` fields, along with per-bind callback `OnPress`

* inital linting pass

* stricter linting

* stricter linting settings

seperate commit so they're easy to revert

* fix circular import

don't worry I tested 🙂

* remove deprecated unrealsdk reference

Author: apple1417

Mods/ModMenu/DeprecationHelper.py

@@ -1,6 +1,12 @@
 import unrealsdk
 import functools
-from typing import Any, Callable, Dict, List, Optional, Set
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple
+
+__all__: Tuple[str, ...] = (
+    "Deprecated",
+    "NameChangeMsg",
+    "PrintWarning",
+)
 
 _printed_deprecation_warnings: Set[str] = set()
 

Mods/ModMenu/HookManager.py

@@ -3,16 +3,25 @@
 import unrealsdk
 import functools
 import weakref
-from typing import Any, Callable, Optional, Union
-from inspect import signature, Parameter
+from inspect import Parameter, signature
+from typing import Any, Callable, Tuple, Union
 
+__all__: Tuple[str, ...] = (
+    "AnyHook",
+    "Hook",
+    "HookFunction",
+    "HookMethod",
+    "RegisterHooks",
+    "RemoveHooks",
+)
 
-_HookFunction = Callable[[unrealsdk.UObject, unrealsdk.UFunction, unrealsdk.FStruct], Any]
-_HookMethod = Callable[[object, unrealsdk.UObject, unrealsdk.UFunction, unrealsdk.FStruct], Any]
-_HookAny = Union[_HookFunction, _HookMethod]
 
+HookFunction = Callable[[unrealsdk.UObject, unrealsdk.UFunction, unrealsdk.FStruct], Any]
+HookMethod = Callable[[object, unrealsdk.UObject, unrealsdk.UFunction, unrealsdk.FStruct], Any]
+AnyHook = Union[HookFunction, HookMethod]
 
-def Hook(target: str, name: str = "{0}.{1}") -> Callable[[_HookAny], _HookAny]:
+
+def Hook(target: str, name: str = "{0}.{1}") -> Callable[[AnyHook], AnyHook]:
     """
     A decorator for functions that should be invoked in response to an Unreal Engine method's
     invokation.
@@ -47,7 +56,7 @@ def Hook(target: str, name: str = "{0}.{1}") -> Callable[[_HookAny], _HookAny]:
             qualified name, separated by a ".". Argument `{1}` will contain the `id()` of the
             function or mod instance.
     """
-    def apply_hook(function: _HookAny) -> _HookAny:
+    def apply_hook(function: AnyHook) -> AnyHook:
         # If the function has four parameters, it should be a method.
         params = signature(function).parameters
         is_method = (len(params) == 4)
@@ -56,45 +65,48 @@ def apply_hook(function: _HookAny) -> _HookAny:
         # initial setup on it now.
         hook_targets = getattr(function, "HookTargets", None)
         if hook_targets is None:
-            paramException = ValueError("Hook functions must have the signature ([self,] caller: unrealsdk.UObject, function: unrealsdk.UFunction, params: unrealsdk.FStruct)")
+            param_exception = ValueError(
+                "Hook functions must have the signature"
+                " ([self,] caller: unrealsdk.UObject, function: unrealsdk.UFunction, params: unrealsdk.FStruct)"
+            )
 
             # If the function is an instance method, create a mutable list of the parameters and
             # remove the `self` one, so we may check the remaining ones same as a non-method.
-            params = list(params.values())
+            param_list = list(params.values())
             if is_method:
-                del params[0]
+                del param_list[0]
             # If the function has neither 4 nor 3 parameters, it is invalid.
-            elif len(params) != 3:
-                raise paramException
+            elif len(param_list) != 3:
+                raise param_exception
             # If the functions parameters do not accept positional arguments, it is invalid.
-            for param in params:
+            for param in param_list:
                 if Parameter.POSITIONAL_ONLY != param.kind != Parameter.POSITIONAL_OR_KEYWORD:
-                    raise paramException
+                    raise param_exception
 
             # If the function is a method, store the name format string on it for formatting with
             # future instances. If it's a simple function, format its name for use now.
-            function.HookName = name if is_method else name.format(
+            function.HookName = name if is_method else name.format(  # type: ignore
                 f"{function.__module__}.{function.__qualname__}", id(function)
             )
 
             # With the function now known as valid, create its set of targets.
-            hook_targets = function.HookTargets = set()
+            hook_targets = function.HookTargets = set()  # type: ignore
 
         hook_targets.add(target)
 
         if not is_method:
-            unrealsdk.RunHook(target, function.HookName, function)
+            unrealsdk.RunHook(target, function.HookName, function)  # type: ignore
 
         return function
     return apply_hook
 
 
-def _create_method_wrapper(obj_ref: weakref.ReferenceType[object], obj_function: _HookMethod) -> _HookFunction:
+def _create_method_wrapper(obj_ref: weakref.ReferenceType[object], obj_function: HookMethod) -> HookFunction:
     """Return a "true" function for the given bound method, passable to `unrealsdk.RegisterHook`."""
     @functools.wraps(obj_function)
     def method_wrapper(caller: unrealsdk.UObject, function: unrealsdk.UFunction, params: unrealsdk.FStruct) -> Any:
         obj = obj_ref()
-        method = obj_function.__get__(obj, type(obj))
+        method = obj_function.__get__(obj, type(obj))  # type: ignore
         return method(caller, obj_function, params)
     return method_wrapper
 
@@ -130,12 +142,12 @@ def RegisterHooks(obj: object) -> None:
         setattr(obj, attribute_name, method_wrapper)
 
         # Format the provided hook name.
-        method_wrapper.HookName = function.HookName.format(
+        method_wrapper.HookName = function.HookName.format(  # type: ignore
             f"{function.__module__}.{function.__qualname__}", id(obj)
         )
 
         for target in hook_targets:
-            unrealsdk.RunHook(target, method_wrapper.HookName, method_wrapper)
+            unrealsdk.RunHook(target, method_wrapper.HookName, method_wrapper)  # type: ignore
 
 
 def RemoveHooks(obj: object) -> None:

Mods/ModMenu/KeybindManager.py

@@ -1,14 +1,18 @@
 import unrealsdk
-import inspect
 import functools
+import inspect
 from dataclasses import dataclass, field
 from enum import IntEnum
-from typing import Callable, ClassVar, Dict, Optional, Union
+from typing import Callable, ClassVar, Dict, Optional, Tuple, Union
 
 from . import DeprecationHelper as dh
-from . import MenuManager
-from . import ModObjects
-from . import SettingsManager
+from . import MenuManager, ModObjects, SettingsManager
+
+__all__: Tuple[str, ...] = (
+    "InputEvent",
+    "Keybind",
+    "KeybindCallback",
+)
 
 
 class InputEvent(IntEnum):
@@ -358,10 +362,12 @@ def HandleInputKey(caller: unrealsdk.UObject, function: unrealsdk.UFunction, par
                 if caller != dialog:
                     return True
 
-                if params.uevent == InputEvent.Released:
-                    if params.ukey in ("Escape", "XboxTypeS_B", "XboxTypeS_Back"):
-                        dialog.Close()
-                        unrealsdk.RemoveHook("WillowGame.WillowGFxDialogBox.HandleInputKey", "ModMenu.KeybindManager")
+                if (
+                    params.uevent == InputEvent.Released
+                    and params.ukey in ("Escape", "XboxTypeS_B", "XboxTypeS_Back")
+                ):
+                    dialog.Close()
+                    unrealsdk.RemoveHook("WillowGame.WillowGFxDialogBox.HandleInputKey", "ModMenu.KeybindManager")
                 return True
 
             unrealsdk.RunHook("WillowGame.WillowGFxDialogBox.HandleInputKey", "ModMenu.KeybindManager", HandleInputKey)

Mods/ModMenu/MenuManager.py

@@ -5,12 +5,14 @@
 import sys
 import webbrowser
 from functools import cmp_to_key
-from typing import Dict, List, Set
+from typing import Dict, List, Set, Tuple
 
-from Mods import ModMenu
+from . import VERSION_MAJOR, VERSION_MINOR
 from . import DeprecationHelper as dh
-from . import KeybindManager
-from . import ModObjects
+from . import KeybindManager, ModObjects
+
+__all__: Tuple[str, ...] = ()
+
 
 _MODS_EVENT_ID: int = 1417
 _MODS_MENU_NAME: str = "MODS"
@@ -61,7 +63,7 @@ class _General(ModObjects.SDKMod):
         "\n"
         "See below for options.\n"
     )
-    Version: str = f"{ModMenu.VERSION_MAJOR}.{ModMenu.VERSION_MINOR}"
+    Version: str = f"{VERSION_MAJOR}.{VERSION_MINOR}"
 
     Types: ModObjects.ModTypes = ModObjects.ModTypes.All
 
@@ -250,7 +252,7 @@ def _ShopInputKey(caller: unrealsdk.UObject, function: unrealsdk.UFunction, para
     if key in ("Escape", "Up", "Down", "W", "S"):
         return True
 
-    if event == KeybindManager.InputEvent.Pressed or event == KeybindManager.InputEvent.Repeat:
+    if event in (KeybindManager.InputEvent.Pressed, KeybindManager.InputEvent.Repeat):
         # These two are bugged on gearbox's end, we manually fix them
         if key == "PageUp":
             caller.ScrollDescription(True)
@@ -358,9 +360,12 @@ def _SharedHandleInputKey(caller: unrealsdk.UObject, function: unrealsdk.UFuncti
     This function is called on pretty much all key input events on the main menu. We use it to open
      the dlc menu when you press "M".
     """
-    if params.ukey == "M" and params.uevent == KeybindManager.InputEvent.Released:
-        if not caller.IsOverlayMenuOpen():
-            caller.CheckDownloadableContentListCompleted(caller.WPCOwner.GetMyControllerId(), True)
+    if (
+        params.ukey == "M"
+        and params.uevent == KeybindManager.InputEvent.Released
+        and not caller.IsOverlayMenuOpen()
+    ):
+        caller.CheckDownloadableContentListCompleted(caller.WPCOwner.GetMyControllerId(), True)
     return True
 
 
@@ -381,8 +386,8 @@ def _FrontEndUpdateTooltips(caller: unrealsdk.UObject, function: unrealsdk.UFunc
         # There's no easy len() :/
         count = 0
         if caller.TheList is not None:
-            for i in caller.TheList.DataProviderStack:
-                count += 1
+            for _ in caller.TheList.DataProviderStack:
+                count += 1  # noqa: SIM113
         if count <= 1:
             cancel = caller.DisconnectString
     tooltip += caller.TooltipSpacing + caller.CancelTooltip.replace("%PLAYER1", cancel)

Mods/ModMenu/ModObjects.py

@@ -6,13 +6,20 @@
 import sys
 from abc import ABCMeta
 from os import path
-from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple
+from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple, cast
+
+from . import HookManager, KeybindManager, NetworkManager, OptionManager, SettingsManager
+
+__all__: Tuple[str, ...] = (
+    "EnabledSaveType",
+    "Game",
+    "ModPriorities",
+    "Mods",
+    "ModTypes",
+    "RegisterMod",
+    "SDKMod",
+)
 
-from . import HookManager
-from . import KeybindManager
-from . import NetworkManager
-from . import OptionManager
-from . import SettingsManager
 
 Mods: List[SDKMod] = []
 
@@ -118,10 +125,10 @@ def __init__(cls, name: str, bases: Tuple[type, ...], attrs: Dict[str, Any]) ->
         for function in functions:
             method_sender = NetworkManager._find_method_sender(function)
             if method_sender is not None:
-                if method_sender._is_server:
-                    cls._server_functions.add(method_sender)
-                if method_sender._is_client:
-                    cls._client_functions.add(method_sender)
+                if method_sender._is_server:  # type: ignore
+                    cls._server_functions.add(method_sender)  # type: ignore
+                if method_sender._is_client:  # type: ignore
+                    cls._client_functions.add(method_sender)  # type: ignore
 
 
 class SDKMod(metaclass=_ModMeta):
@@ -245,9 +252,8 @@ def SettingsInputPressed(self, action: str) -> None:
             action: The name of the action.
         """
         # Even though we removed these from `SettingsInputs`, need this check for auto enable
-        if Game.GetCurrent() not in self.SupportedGames:
-            if action in ("Enable", "Disable"):
-                return
+        if Game.GetCurrent() not in self.SupportedGames and action in ("Enable", "Disable"):
+            return
 
         if action == "Enable":
             if not self.IsEnabled:
@@ -302,11 +308,12 @@ def ModOptionChanged(self, option: OptionManager.Options.Base, new_value: Any) -
         pass
 
     @staticmethod
-    def NetworkSerialize(arguments: dict) -> str:
+    def NetworkSerialize(arguments: NetworkManager.NetworkArgsDict) -> str:
         """
         Called when instances of this class invoke methods decorated with `@ModMenu.ServerMethod`
         or `@ModMenu.ClientMethod`, performing the serialization of any arguments passed to said
         methods. The default implementation uses `json.dumps()`.
+
         Arguments:
             arguments:
                 The arguments that need to be serialized. The top-level object passed will be a
@@ -317,15 +324,16 @@ def NetworkSerialize(arguments: dict) -> str:
         return json.dumps(arguments)
 
     @staticmethod
-    def NetworkDeserialize(serialized: str) -> dict:
+    def NetworkDeserialize(serialized: str) -> NetworkManager.NetworkArgsDict:
         """
         Called when instances of this class receive requests for methods decorated with
         `@ModMenu.ServerMethod` or `@ModMenu.ClientMethod`, performing the deserialization of any
         arguments passed to said methods. The default implementation uses `json.loads()`.
+
         Arguments:
             serialized:
                 The string containing the serialized arguments as returned by 'NetworkSerialize'.
         Returns:
             The deserialized arguments in the same format as they were passed to `NetworkSerialize`.
         """
-        return json.loads(serialized)
+        return cast(NetworkManager.NetworkArgsDict, json.loads(serialized))