Update dev-dependencies

Author: TitanNano

decompile_ts4.sh

@@ -15,29 +15,29 @@ function progress {
 
 source_dir=$TS4_DECOMPRESSED_SOURCE
 
-files=$(find $source_dir -name '*.pyc')
+files=$(find "$source_dir" -name '*.pyc')
 files_total=$(echo "$files" | wc -l)
 files_done=0
 
 for file in $files
 do
     out_dir="$script_dir/ts4/$(dirname ${file#$source_dir})/"
-    mkdir -p $out_dir
-    uv run decompyle3 -o $out_dir $file &
+    mkdir -p "$out_dir"
+    uv run uncompyle6 -o "$out_dir" "$file" &
 
-    progress $(($files_done*100/$files_total))
+    progress $((files_done*100/files_total))
 
     if [[ $(jobs -r | wc -l) -ge 10 ]]; then
         wait -fn
         files_done=$((files_done+1))
-        progress $(($files_done*100/$files_total))
+        progress $((files_done*100/files_total))
     fi
 done
 
 while [[ $(jobs -r | wc -l) -gt 0 ]]; do
     wait -fn
     files_done=$((files_done+1))
-    progress $(($files_done*100/$files_total))
+    progress $((files_done*100/files_total))
 done
 
 echo ""

pyproject.toml

@@ -12,11 +12,11 @@ email = "jovan.gerodetti@titannano.de>"
 
 [tool.uv]
 dev-dependencies = [
-    "ruff~=0.4.7",
-    "decompyle3~=3.9.1",
-    "pylint~=2.6.0",
-    "python-lsp-server[rope]~=1.7.4",
-    "pylsp-mypy~=0.6.7",
+    "ruff>=0.11.0",
+    "pylint>=2.6.0",
+    "python-lsp-server[rope]>=1.7.4",
+    "pylsp-mypy>=0.6.7",
+    "uncompyle6>=3.9.2",
 ]
 
 [tool.ruff.lint]

src/control_any_sim/canys_interactions.py

@@ -195,7 +195,7 @@ def _run_interaction_gen(self: Self, timeline: Timeline) -> bool:
             return False
 
     @classmethod
-    def _must_be_selectable(cls: type[C], sim_info: SimInfo) -> bool:
+    def _must_be_selectable(cls, sim_info: SimInfo) -> bool:
         return services.active_household_id() == sim_info.household_id
 
 

src/control_any_sim/util/game_events.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import traceback
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, TypeVar
+from typing import TYPE_CHECKING, Callable, ClassVar, TypeVar
 
 import services
 from server.client import Client
@@ -43,20 +43,20 @@ class GameEvents:
     travel_sim_out_handlers: ClassVar[list[OnTravelSimOut]] = []
 
     @classmethod
-    def on_zone_teardown(cls: type[C], handler: OnZoneTeardown) -> None:
+    def on_zone_teardown(cls, handler: OnZoneTeardown) -> None:
         """Add a listener for the zone_teardown event."""
         cls.zone_teardown_handlers.append(handler)
 
     @classmethod
-    def remove_zone_teardown(cls: type[C], handler: OnZoneTeardown) -> None:
+    def remove_zone_teardown(cls, handler: OnZoneTeardown) -> None:
         """Remove a listener for the zone_teardown event."""
         if handler not in cls.zone_teardown_handlers:
             return
 
         cls.zone_teardown_handlers.remove(handler)
 
     @classmethod
-    def emit_zone_teardown(cls: type[C], current_zone: Zone, client: Client) -> None:
+    def emit_zone_teardown(cls, current_zone: Zone, client: Client) -> None:
         """Emit a zone teardown event."""
         Logger.log(
             f"registered zone teardown handlers: {len(cls.zone_teardown_handlers)}",
@@ -66,13 +66,13 @@ def emit_zone_teardown(cls: type[C], current_zone: Zone, client: Client) -> None
             handler(current_zone, client)
 
     @classmethod
-    def on_zone_spin_up(cls: type[C], handler: OnZoneSpinUp) -> None:
+    def on_zone_spin_up(cls, handler: OnZoneSpinUp) -> None:
         """Add a listener for the zone_spin_up event."""
         cls.zone_spin_up_handlers.append(handler)
 
     @classmethod
     def emit_zone_spin_up(
-        cls: type[C],
+        cls,
         current_zone: Zone,
         household_id: int,
         active_sim_id: int,
@@ -82,12 +82,12 @@ def emit_zone_spin_up(
             handler(current_zone, household_id, active_sim_id)
 
     @classmethod
-    def on_add_sim(cls: type[C], handler: OnAddSim) -> None:
+    def on_add_sim(cls, handler: OnAddSim) -> None:
         """Add a listener for the add_sim event."""
         cls.add_sim_handlers.append(handler)
 
     @classmethod
-    def emit_add_sim(cls: type[C], sim: Sim) -> None:
+    def emit_add_sim(cls, sim: Sim) -> None:
         """Emit the add sim event."""
         for handler in cls.add_sim_handlers:
             handler(sim)
@@ -99,28 +99,28 @@ def on_active_sim_changed(handler: OnActiveSimChanged) -> None:
 
     @classmethod
     def on_loading_screen_animation_finished(
-        cls: type[C],
+        cls,
         handler: OnLoadingScreenAnimationFinished,
     ) -> None:
         """Add a listener for the loading_screen_animation_finished event."""
         cls.loading_screen_animation_finished_handlers.append(handler)
 
     @classmethod
     def emit_loading_screen_animation_finished(
-        cls: type[C],
+        cls,
         current_zone: Zone,
     ) -> None:
         """Emit the loading screen finished event."""
         for handler in cls.loading_screen_animation_finished_handlers:
             handler(current_zone)
 
     @classmethod
-    def on_travel_sim_out(cls: type[C], handler: OnTravelSimOut) -> None:
+    def on_travel_sim_out(cls, handler: OnTravelSimOut) -> None:
         """Add a listener for the travel_sim_out event."""
         cls.travel_sim_out_handlers.append(handler)
 
     @classmethod
-    def emit_travel_sim_out(cls: type[C], sim_info: SimInfo) -> None:
+    def emit_travel_sim_out(cls, sim_info: SimInfo) -> None:
         """Emit the travel sim out event."""
         for handler in cls.travel_sim_out_handlers:
             handler(sim_info)
@@ -133,10 +133,10 @@ def on_post_spawn_sim(handler: OnPostSpawnSim) -> None:
 
 @inject_method_to(Zone, "on_teardown")
 def canys_zone_on_teardown(
-    original: Callable[[Zone, Client], Any],
+    original: Callable[[Zone, Client], None],
     self: Zone,
     client: Client,
-) -> Any:  # noqa: ANN401
+) -> None:
     """Wrap around the Zone::on_teardown method to emit the coresponding event."""
     try:
         Logger.log("Zone.on_teardown event occurred")

src/control_any_sim/util/serialize.py

@@ -5,18 +5,25 @@
 import json
 from typing import Any, Callable, TypeVar
 
+from typing_extensions import Self
+
 C = TypeVar("C")
 
 
 def dict_to_obj(cls: type[C]) -> Callable[[dict[str, Any]], C]:
-    """Convert a dict into an object."""
+    """
+    Convert a dict into an object.
+
+    Returns
+    -------
+        A function that converts an object into a dictionary.
+
+    """
 
     def hook(our_dict: dict[str, Any]) -> C:
-        if "__class__" in our_dict:
-            del our_dict["__class__"]
+        our_dict.pop("__class__", None)
 
-        if "__module__" in our_dict:
-            del our_dict["__module__"]
+        our_dict.pop("__module__", None)
 
         # Use dictionary unpacking to initialize the object
         return cls(**our_dict)
@@ -28,8 +35,12 @@ def object_to_dict(obj: object) -> dict[str, Any]:
     """
     Convert object to dict.
 
-    Takes in a custom object and returns a dictionary representation
-    of the object.
+    Takes in a custom object
+
+    Returns
+    -------
+        A dictionary representation of the object.
+
     """
     return obj.__dict__
 
@@ -38,10 +49,24 @@ class Serializable:
     """Class that can be serialized to JSON."""
 
     def serialize(self: object) -> str:
-        """Serialize an object into a JSON string."""
+        """
+        Serialize an object into a JSON string.
+
+        Returns
+        -------
+            A JSON string of the serialized data.
+
+        """
         return json.dumps(self, default=object_to_dict, indent=4, sort_keys=True)
 
     @classmethod
-    def deserialize(cls: type[C], data: str) -> C:
-        """Deserialize an object from a JSON string."""
+    def deserialize(cls, data: str) -> Self:
+        """
+        Deserialize an object from a JSON string.
+
+        Returns
+        -------
+            A new instance of Self.
+
+        """
         return json.loads(data, object_hook=dict_to_obj(cls))