Update ruff settings and fix rules C417 and UP032

Author: cclauss

examples/sc2autosave.py

@@ -373,9 +373,7 @@ def reset(args):
         exit("Cannot reset, destination must be directory: {0}", args.dest)
 
     print(
-        "About to reset directory: {}\nAll files and subdirectories will be removed.".format(
-            args.dest
-        )
+        f"About to reset directory: {args.dest}\nAll files and subdirectories will be removed."
     )
     choice = raw_input("Proceed anyway? (y/n) ")
     if choice.lower() == "y":

generate_build_data.py

@@ -103,9 +103,7 @@ def generate_build_data(balance_data_path):
                     if element_ability_index != train_ability_index:
                         train_ability_index = element_ability_index
 
-                        train_ability_name = "{}Train{}".format(
-                            unit_id, trained_unit_name
-                        )
+                        train_ability_name = f"{unit_id}Train{trained_unit_name}"
                         abilities[train_ability_index] = train_ability_name
 
                         if train_ability_name not in ability_lookup:

pyproject.toml

@@ -13,9 +13,9 @@ keywords = [
   "sc2",
   "starcraft 2",
 ]
-license = {text = "MIT"}
-authors = [{name = "Kevin Leung", email = "[email protected]"}]
-requires-python = ">=3.7"
+license = { text = "MIT" }
+authors = [ { name = "Kevin Leung", email = "[email protected]" } ]
+requires-python = ">=3.9"
 classifiers = [
   "Development Status :: 5 - Production/Stable",
   "Environment :: Console",
@@ -25,11 +25,11 @@ classifiers = [
   "Operating System :: OS Independent",
   "Programming Language :: Python",
   "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.7",
-  "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
   "Topic :: Games/Entertainment",
@@ -46,27 +46,35 @@ dependencies = [
   "mpyq",
   "pillow",
 ]
-[project.optional-dependencies]
-testing = [
+optional-dependencies.testing = [
   "pytest",
 ]
-[project.urls]
-Homepage = "https://github.com/ggtracker/sc2reader"
-[project.scripts]
-sc2attributes = "sc2reader.scripts.sc2attributes:main"
-sc2json = "sc2reader.scripts.sc2json:main"
-sc2parse = "sc2reader.scripts.sc2parse:main"
-sc2printer = "sc2reader.scripts.sc2printer:main"
-sc2replayer = "sc2reader.scripts.sc2replayer:main"
+urls.Homepage = "https://github.com/ggtracker/sc2reader"
+scripts.sc2attributes = "sc2reader.scripts.sc2attributes:main"
+scripts.sc2json = "sc2reader.scripts.sc2json:main"
+scripts.sc2parse = "sc2reader.scripts.sc2parse:main"
+scripts.sc2printer = "sc2reader.scripts.sc2printer:main"
+scripts.sc2replayer = "sc2reader.scripts.sc2replayer:main"
 
 [tool.setuptools]
 include-package-data = true
 zip-safe = true
-platforms = ["any"]
+platforms = [ "any" ]
 
 [tool.setuptools.dynamic]
-readme = {file = ["README.rst", "CHANGELOG.rst"]}
-version = {attr = "sc2reader.__version__"}
+readme = { file = [ "README.rst", "CHANGELOG.rst" ] }
+version = { attr = "sc2reader.__version__" }
 
 [tool.setuptools.packages]
-find = {namespaces = false}
+find = { namespaces = false }
+
+[tool.ruff]
+line-length = 129
+
+lint.ignore = [
+  "F401", # module imported but unused; consider using `importlib.util.find_spec` to test for availability
+  "F403", # Run `removestar` on this codebase
+  "F405", # Run `removestar` on this codebase
+  "F841", # Run `ruff --select=F841 --fix .`
+]
+lint.mccabe.max-complexity = 34

ruff.toml

@@ -339,9 +339,7 @@ def change_type(self, unit, new_type, frame):
             unit.set_type(unit_type, frame)
         else:
             self.logger.error(
-                "Unable to change type of {} to {} [frame {}]; unit type not found in build {}".format(
-                    unit, new_type, frame, self.id
-                )
+                f"Unable to change type of {unit} to {new_type} [frame {frame}]; unit type not found in build {self.id}"
             )
 
     def add_ability(

sc2reader/data/__init__.py

@@ -43,12 +43,7 @@ def handleCommandEvent(self, event, replay):
                         event.logger.error("\t" + player.__str__())
 
             self.logger.error(
-                "{}\t{}\tMissing ability {:X} from {}".format(
-                    event.frame,
-                    event.player.name,
-                    event.ability_id,
-                    replay.datapack.__class__.__name__,
-                )
+                f"{event.frame}\t{event.player.name}\tMissing ability {event.ability_id:X} from {replay.datapack.__class__.__name__}"
             )
 
         else:
@@ -197,15 +192,11 @@ def handleUnitDiedEvent(self, event, replay):
                 del replay.active_units[event.unit_id_index]
             else:
                 self.logger.error(
-                    "Unable to delete unit index {} at {} [{}], index not active.".format(
-                        event.unit_id_index, Length(seconds=event.second), event.frame
-                    )
+                    f"Unable to delete unit index {event.unit_id_index} at {Length(seconds=event.second)} [{event.frame}], index not active."
                 )
         else:
             self.logger.error(
-                "Unit {} died at {} [{}] before it was born!".format(
-                    event.unit_id, Length(seconds=event.second), event.frame
-                )
+                f"Unit {event.unit_id} died at {Length(seconds=event.second)} [{event.frame}] before it was born!"
             )
 
         if event.killing_player_id in replay.player:
@@ -215,9 +206,7 @@ def handleUnitDiedEvent(self, event, replay):
                 event.killing_player.killed_units.append(event.unit)
         elif event.killing_player_id:
             self.logger.error(
-                "Unknown killing player id {} at {} [{}]".format(
-                    event.killing_player_id, Length(seconds=event.second), event.frame
-                )
+                f"Unknown killing player id {event.killing_player_id} at {Length(seconds=event.second)} [{event.frame}]"
             )
 
         if event.killing_unit_id in replay.objects:
@@ -227,9 +216,7 @@ def handleUnitDiedEvent(self, event, replay):
                 event.killing_unit.killed_units.append(event.unit)
         elif event.killing_unit_id:
             self.logger.error(
-                "Unknown killing unit id {} at {} [{}]".format(
-                    event.killing_unit_id, Length(seconds=event.second), event.frame
-                )
+                f"Unknown killing unit id {event.killing_unit_id} at {Length(seconds=event.second)} [{event.frame}]"
             )
 
     def handleUnitOwnerChangeEvent(self, event, replay):
@@ -243,9 +230,7 @@ def handleUnitOwnerChangeEvent(self, event, replay):
             event.unit = replay.objects[event.unit_id]
         else:
             self.logger.error(
-                "Unit {} owner changed at {} [{}] before it was born!".format(
-                    event.unit_id, Length(seconds=event.second), event.frame
-                )
+                f"Unit {event.unit_id} owner changed at {Length(seconds=event.second)} [{event.frame}] before it was born!"
             )
 
         if event.unit_upkeeper and event.unit:
@@ -263,9 +248,7 @@ def handleUnitTypeChangeEvent(self, event, replay):
             replay.datapack.change_type(event.unit, event.unit_type_name, event.frame)
         else:
             self.logger.error(
-                "Unit {} type changed at {} before it was born!".format(
-                    event.unit_id, Length(seconds=event.second)
-                )
+                f"Unit {event.unit_id} type changed at {Length(seconds=event.second)} before it was born!"
             )
 
     def handleUpgradeCompleteEvent(self, event, replay):
@@ -306,9 +289,7 @@ def handleUnitDoneEvent(self, event, replay):
             event.unit.finished_at = event.frame
         else:
             self.logger.error(
-                "Unit {} done at {} [{}] before it was started!".format(
-                    event.unit_id, Length(seconds=event.second), event.frame
-                )
+                f"Unit {event.unit_id} done at {Length(seconds=event.second)} [{event.frame}] before it was started!"
             )
 
     def handleUnitPositionsEvent(self, event, replay):
@@ -322,9 +303,7 @@ def handleUnitPositionsEvent(self, event, replay):
                 event.units[unit] = unit.location
             else:
                 self.logger.error(
-                    "Unit at active_unit index {} moved at {} [{}] but it doesn't exist!".format(
-                        unit_index, Length(seconds=event.second), event.frame
-                    )
+                    f"Unit at active_unit index {unit_index} moved at {Length(seconds=event.second)} [{event.frame}] but it doesn't exist!"
                 )
 
     def load_message_game_player(self, event, replay):
@@ -336,12 +315,7 @@ def load_message_game_player(self, event, replay):
                 event.player.events.append(event)
             elif event.pid != 16:
                 self.logger.error(
-                    "Bad pid ({}) for event {} at {} [{}].".format(
-                        event.pid,
-                        event.__class__,
-                        Length(seconds=event.second),
-                        event.frame,
-                    )
+                    f"Bad pid ({event.pid}) for event {event.__class__} at {Length(seconds=event.second)} [{event.frame}]."
                 )
             else:
                 pass  # This is a global event
@@ -352,12 +326,7 @@ def load_message_game_player(self, event, replay):
                 event.player.events.append(event)
             elif event.pid != 16:
                 self.logger.error(
-                    "Bad pid ({}) for event {} at {} [{}].".format(
-                        event.pid,
-                        event.__class__,
-                        Length(seconds=event.second),
-                        event.frame,
-                    )
+                    f"Bad pid ({event.pid}) for event {event.__class__} at {Length(seconds=event.second)} [{event.frame}]."
                 )
             else:
                 pass  # This is a global event
@@ -367,36 +336,21 @@ def load_tracker_player(self, event, replay):
             event.player = replay.entity[event.pid]
         else:
             self.logger.error(
-                "Bad pid ({}) for event {} at {} [{}].".format(
-                    event.pid,
-                    event.__class__,
-                    Length(seconds=event.second),
-                    event.frame,
-                )
+                f"Bad pid ({event.pid}) for event {event.__class__} at {Length(seconds=event.second)} [{event.frame}]."
             )
 
     def load_tracker_upkeeper(self, event, replay):
         if event.upkeep_pid in replay.entity:
             event.unit_upkeeper = replay.entity[event.upkeep_pid]
         elif event.upkeep_pid != 0:
             self.logger.error(
-                "Bad upkeep_pid ({}) for event {} at {} [{}].".format(
-                    event.upkeep_pid,
-                    event.__class__,
-                    Length(seconds=event.second),
-                    event.frame,
-                )
+                f"Bad upkeep_pid ({event.upkeep_pid}) for event {event.__class__} at {Length(seconds=event.second)} [{event.frame}]."
             )
 
     def load_tracker_controller(self, event, replay):
         if event.control_pid in replay.entity:
             event.unit_controller = replay.entity[event.control_pid]
         elif event.control_pid != 0:
             self.logger.error(
-                "Bad control_pid ({}) for event {} at {} [{}].".format(
-                    event.control_pid,
-                    event.__class__,
-                    Length(seconds=event.second),
-                    event.frame,
-                )
+                f"Bad control_pid ({event.control_pid}) for event {event.__class__} at {Length(seconds=event.second)} [{event.frame}]."
             )

sc2reader/engine/plugins/context.py

@@ -229,7 +229,7 @@ def cgu_in_min_to_cgu_units(self, player_id, cgu_in_minutes):
         ## this function takes index and value of CGU times and returns
         ## the cgu units with the maximum length
         for cgu_per_minute in cgu_in_minutes:
-            indexes = map(lambda x: x[0], cgu_per_minute)
+            indexes = (x[0] for x in cgu_per_minute)
             cgu_units = list()
             for index in indexes:
                 cgu_units.append(self.creep_gen_units[player_id][index])
@@ -247,16 +247,16 @@ def reduce_cgu_per_minute(self, player_id):
         cgu_unit_max_per_minute = self.cgu_in_min_to_cgu_units(
             player_id, cgu_per_minute1
         )
-        minutes = map(lambda x: int(x[0][1] // 60) * 60, cgu_per_minute2)
+        minutes = (int(x[0][1] // 60) * 60 for x in cgu_per_minute2)
         self.creep_gen_units[player_id] = list(cgu_unit_max_per_minute)
         self.creep_gen_units_times[player_id] = list(minutes)
 
     def get_creep_spread_area(self, player_id):
         ## iterates through all cgus and and calculate the area
         for index, cgu_per_player in enumerate(self.creep_gen_units[player_id]):
             # convert cgu list into centre of circles and radius
-            cgu_radius = map(
-                lambda x: (x[1], self.unit_name_to_radius[x[2]]), cgu_per_player
+            cgu_radius = (
+                (x[1], self.unit_name_to_radius[x[2]]) for x in cgu_per_player
             )
             # convert event coords to minimap coords
             cgu_radius = self.convert_cgu_radius_event_to_map_coord(cgu_radius)
@@ -286,9 +286,9 @@ def cgu_radius_to_map_positions(self, cgu_radius, radius_to_coordinates):
             radius = cgu[1]
             ## subtract all radius_to_coordinates with centre of
             ## cgu radius to change centre of circle
-            cgu_map_position = map(
-                lambda x: (x[0] + point[0], x[1] + point[1]),
-                self.radius_to_coordinates[radius],
+            cgu_map_position = (
+                (x[0] + point[0], x[1] + point[1])
+                for x in self.radius_to_coordinates[radius]
             )
             total_points_on_map = total_points_on_map | Set(cgu_map_position)
         return total_points_on_map

sc2reader/engine/plugins/creeptracker.py

@@ -38,9 +38,7 @@ def _str_prefix(self):
         if getattr(self, "pid", 16) == 16:
             player_name = "Global"
         elif self.player and not self.player.name:
-            player_name = "Player {} - ({})".format(
-                self.player.pid, self.player.play_race
-            )
+            player_name = f"Player {self.player.pid} - ({self.player.play_race})"
         elif self.player:
             player_name = self.player.name
         else:
@@ -244,9 +242,7 @@ def __str__(self):
             string += "Right Click"
 
         if self.ability_type == "TargetUnit":
-            string += "; Target: {} [{:0>8X}]".format(
-                self.target.name, self.target_unit_id
-            )
+            string += f"; Target: {self.target.name} [{self.target_unit_id:0>8X}]"
 
         if self.ability_type in ("TargetPoint", "TargetUnit"):
             string += f"; Location: {str(self.location)}"
@@ -643,7 +639,7 @@ def __init__(self, frame, pid, data):
         self.yaw = data["yaw"]
 
     def __str__(self):
-        return self._str_prefix() + "{} at ({}, {})".format(self.name, self.x, self.y)
+        return self._str_prefix() + f"{self.name} at ({self.x}, {self.y})"
 
 
 @loggable
@@ -686,13 +682,7 @@ def __init__(self, frame, pid, data):
     def __str__(self):
         return (
             self._str_prefix()
-            + " transfer {} minerals, {} gas, {} terrazine, and {} custom to {}".format(
-                self.minerals,
-                self.vespene,
-                self.terrazine,
-                self.custom_resource,
-                self.recipient,
-            )
+            + f" transfer {self.minerals} minerals, {self.vespene} gas, {self.terrazine} terrazine, and {self.custom_resource} custom to {self.recipient}"
         )
 
 
@@ -722,9 +712,7 @@ def __init__(self, frame, pid, data):
     def __str__(self):
         return (
             self._str_prefix()
-            + " requests {} minerals, {} gas, {} terrazine, and {} custom".format(
-                self.minerals, self.vespene, self.terrazine, self.custom_resource
-            )
+            + f" requests {self.minerals} minerals, {self.vespene} gas, {self.terrazine} terrazine, and {self.custom_resource} custom"
         )