Update packages and apply autoformat

Author: BurnySc2

examples/watch_replay.py

@@ -37,7 +37,7 @@ async def on_step(self, iteration: int):
         # Convert relative path to absolute path, assuming this replay is in this folder
         folder_path = Path(__file__).parent
         replay_path = folder_path / replay_name
-    assert (
-        replay_path.is_file()
-    ), "Run worker_rush.py in the same folder first to generate a replay. Then run watch_replay.py again."
+    assert replay_path.is_file(), (
+        "Run worker_rush.py in the same folder first to generate a replay. Then run watch_replay.py again."
+    )
     run_replay(my_observer_ai, replay_path=str(replay_path))

generate_dicts_from_data_json.py

@@ -205,9 +205,9 @@ def get_unit_train_build_abilities(data):
                 requirements: list[dict[str, int]] = ability_info.get("requirements", [])
                 if requirements:
                     # Assume train abilities only have one tech building requirement; thors requiring armory and techlab is seperatedly counted
-                    assert (
-                        len([req for req in requirements if req.get("building", 0)]) <= 1
-                    ), f"Error: Building {unit_type} has more than one tech requirements with train ability {ability_id}"
+                    assert len([req for req in requirements if req.get("building", 0)]) <= 1, (
+                        f"Error: Building {unit_type} has more than one tech requirements with train ability {ability_id}"
+                    )
                     # UnitTypeId 5 == Techlab
                     requires_techlab: bool = any(req for req in requirements if req.get("addon", 0) == 5)
                     requires_tech_builing_id_value: int = next(
@@ -404,9 +404,9 @@ def generate_unit_alias_dict(data: dict):
 
         current_unit_tech_aliases: set[UnitTypeId] = OrderedSet2()
 
-        assert (
-            unit_type_value in game_data.units
-        ), f"Unit {unit_type} not listed in game_data.units - perhaps pickled file {pickled_file_path} is outdated?"
+        assert unit_type_value in game_data.units, (
+            f"Unit {unit_type} not listed in game_data.units - perhaps pickled file {pickled_file_path} is outdated?"
+        )
         unit_alias: int = game_data.units[unit_type_value]._proto.unit_alias
         if unit_alias:
             # Might be 0 if it has no alias

sc2/action.py

@@ -45,7 +45,7 @@ def combine_actions(action_iter):
             elif isinstance(target, Unit):
                 cmd.target_unit_tag = target.tag
             elif target is not None:
-                raise RuntimeError(f"Must target a unit, point or None, found '{target !r}'")
+                raise RuntimeError(f"Must target a unit, point or None, found '{target!r}'")
 
             yield raw_pb.ActionRaw(unit_command=cmd)
 
@@ -84,4 +84,4 @@ def combine_actions(action_iter):
                     )
                     yield raw_pb.ActionRaw(unit_command=cmd)
             else:
-                raise RuntimeError(f"Must target a unit, point or None, found '{target !r}'")
+                raise RuntimeError(f"Must target a unit, point or None, found '{target!r}'")

sc2/bot_ai.py

@@ -152,7 +152,9 @@ def main_base_ramp(self) -> Ramp:
     @property_cache_once_per_frame
     def expansion_locations_list(self) -> list[Point2]:
         """Returns a list of expansion positions, not sorted in any way."""
-        assert self._expansion_positions_list, "self._find_expansion_locations() has not been run yet, so accessing the list of expansion locations is pointless."
+        assert self._expansion_positions_list, (
+            "self._find_expansion_locations() has not been run yet, so accessing the list of expansion locations is pointless."
+        )
         return self._expansion_positions_list
 
     @property_cache_once_per_frame
@@ -163,7 +165,9 @@ def expansion_locations_dict(self) -> dict[Point2, Units]:
 
         Caution: This function is slow. If you only need the expansion locations, use the property above.
         """
-        assert self._expansion_positions_list, "self._find_expansion_locations() has not been run yet, so accessing the list of expansion locations is pointless."
+        assert self._expansion_positions_list, (
+            "self._find_expansion_locations() has not been run yet, so accessing the list of expansion locations is pointless."
+        )
         expansion_locations: dict[Point2, Units] = {pos: Units([], self) for pos in self._expansion_positions_list}
         for resource in self.resources:
             # It may be that some resources are not mapped to an expansion location
@@ -654,9 +658,9 @@ async def can_place(self, building: AbilityData | AbilityId | UnitTypeId, positi
             )
             return await self.can_place_single(building, positions)
         assert isinstance(positions, list), f"Expected an iterable (list, tuple), but was: {positions}"
-        assert isinstance(
-            positions[0], Point2
-        ), f"List is expected to have Point2, but instead had: {positions[0]} {type(positions[0])}"
+        assert isinstance(positions[0], Point2), (
+            f"List is expected to have Point2, but instead had: {positions[0]} {type(positions[0])}"
+        )
         return await self.client._query_building_placement_fast(building, positions)
 
     async def find_placement(
@@ -780,9 +784,9 @@ def structure_type_build_progress(self, structure_type: UnitTypeId | int) -> flo
 
         :param structure_type:
         """
-        assert isinstance(
-            structure_type, (int, UnitTypeId)
-        ), f"Needs to be int or UnitTypeId, but was: {type(structure_type)}"
+        assert isinstance(structure_type, (int, UnitTypeId)), (
+            f"Needs to be int or UnitTypeId, but was: {type(structure_type)}"
+        )
         if isinstance(structure_type, int):
             structure_type_value: int = structure_type
             structure_type = UnitTypeId(structure_type_value)
@@ -1111,9 +1115,9 @@ def research(self, upgrade_type: UpgradeId) -> bool:
 
         :param upgrade_type:
         """
-        assert (
-            upgrade_type in UPGRADE_RESEARCHED_FROM
-        ), f"Could not find upgrade {upgrade_type} in 'research from'-dictionary"
+        assert upgrade_type in UPGRADE_RESEARCHED_FROM, (
+            f"Could not find upgrade {upgrade_type} in 'research from'-dictionary"
+        )
 
         # Not affordable
         if not self.can_afford(upgrade_type):

sc2/bot_ai_internal.py

@@ -167,7 +167,9 @@ def _client(self) -> Client:
     @property_cache_once_per_frame
     def expansion_locations(self) -> dict[Point2, Units]:
         """Same as the function above."""
-        assert self._expansion_positions_list, "self._find_expansion_locations() has not been run yet, so accessing the list of expansion locations is pointless."
+        assert self._expansion_positions_list, (
+            "self._find_expansion_locations() has not been run yet, so accessing the list of expansion locations is pointless."
+        )
         warnings.warn(
             "You are using 'self.expansion_locations', please use 'self.expansion_locations_list' (fast) or 'self.expansion_locations_dict' (slow) instead.",
             DeprecationWarning,
@@ -372,9 +374,9 @@ def do(
                 )
             return action
 
-        assert isinstance(
-            action, UnitCommand
-        ), f"Given unit command is not a command, but instead of type {type(action)}"
+        assert isinstance(action, UnitCommand), (
+            f"Given unit command is not a command, but instead of type {type(action)}"
+        )
         if subtract_cost:
             cost: Cost = self.game_data.calculate_ability_cost(action.ability)
             if can_afford_check and not (self.minerals >= cost.minerals and self.vespene >= cost.vespene):
@@ -400,9 +402,9 @@ async def synchronous_do(self, action: UnitCommand):
         This function is only useful for realtime=True in the first frame of the game to instantly produce a worker
         and split workers on the mineral patches.
         """
-        assert isinstance(
-            action, UnitCommand
-        ), f"Given unit command is not a command, but instead of type {type(action)}"
+        assert isinstance(action, UnitCommand), (
+            f"Given unit command is not a command, but instead of type {type(action)}"
+        )
         if not self.can_afford(action.ability):
             logger.warning(f"Cannot afford action {action}")
             return ActionResult.Error
@@ -888,9 +890,9 @@ def _distance_squared_unit_to_unit_method1(self, unit1: Unit, unit2: Unit) -> fl
             return 0
         # Calculate index, needs to be after pdist has been calculated and cached
         condensed_index = self.square_to_condensed(unit1.distance_calculation_index, unit2.distance_calculation_index)
-        assert (
-            condensed_index < len(self._cached_pdist)
-        ), f"Condensed index is larger than amount of calculated distances: {condensed_index} < {len(self._cached_pdist)}, units that caused the assert error: {unit1} and {unit2}"
+        assert condensed_index < len(self._cached_pdist), (
+            f"Condensed index is larger than amount of calculated distances: {condensed_index} < {len(self._cached_pdist)}, units that caused the assert error: {unit1} and {unit2}"
+        )
         distance = self._pdist[condensed_index]
         return distance
 

sc2/client.py

@@ -657,12 +657,12 @@ async def debug_set_unit_value(
             unit_tags = unit_tags.tags
         if isinstance(unit_tags, Unit):
             unit_tags = [unit_tags.tag]
-        assert hasattr(
-            unit_tags, "__iter__"
-        ), f"unit_tags argument needs to be an iterable (list, dict, set, Units), given argument is {type(unit_tags).__name__}"
-        assert (
-            1 <= unit_value <= 3
-        ), f"unit_value needs to be between 1 and 3 (1 for energy, 2 for life, 3 for shields), given argument is {unit_value}"
+        assert hasattr(unit_tags, "__iter__"), (
+            f"unit_tags argument needs to be an iterable (list, dict, set, Units), given argument is {type(unit_tags).__name__}"
+        )
+        assert 1 <= unit_value <= 3, (
+            f"unit_value needs to be between 1 and 3 (1 for energy, 2 for life, 3 for shields), given argument is {unit_value}"
+        )
         assert all(tag > 0 for tag in unit_tags), f"Unit tags have invalid value: {unit_tags}"
         assert isinstance(value, (int, float)), "Value needs to be of type int or float"
         assert value >= 0, "Value can't be negative"

sc2/generate_ids.py

@@ -87,12 +87,12 @@ def parse_data(self, data) -> dict[str, Any]:
                 if v["friendlyname"] != "":
                     key = v["friendlyname"]
                 else:
-                    sys.exit(f"Not mapped: {v !r}")
+                    sys.exit(f"Not mapped: {v!r}")
 
             key = key.upper().replace(" ", "_").replace("@", "")
 
             if "name" in v:
-                key = f'{v["name"].upper().replace(" ", "_")}_{key}'
+                key = f"{v['name'].upper().replace(' ', '_')}_{key}"
 
             if "friendlyname" in v:
                 key = v["friendlyname"].upper().replace(" ", "_")
@@ -147,7 +147,7 @@ def generate_python_code(self, enums) -> None:
         idsdir.mkdir(exist_ok=True)
 
         with (idsdir / "__init__.py").open("w") as f:
-            initstring = f"__all__ = {[n.lower() for n in self.FILE_TRANSLATE.values()] !r}\n".replace("'", '"')
+            initstring = f"__all__ = {[n.lower() for n in self.FILE_TRANSLATE.values()]!r}\n".replace("'", '"')
             f.write("\n".join([self.HEADER, initstring]))
 
         for name, body in enums.items():

sc2/main.py

@@ -491,9 +491,9 @@ async def run_host_and_join():
 def run_replay(ai, replay_path: Path | str, realtime: bool = False, observed_id: int = 0):
     portconfig = Portconfig()
     assert Path(replay_path).is_file(), f"Replay does not exist at the given path: {replay_path}"
-    assert Path(
-        replay_path
-    ).is_absolute(), f'Replay path has to be an absolute path, e.g. "C:/replays/my_replay.SC2Replay" but given path was "{replay_path}"'
+    assert Path(replay_path).is_absolute(), (
+        f'Replay path has to be an absolute path, e.g. "C:/replays/my_replay.SC2Replay" but given path was "{replay_path}"'
+    )
     base_build, data_version = get_replay_version(replay_path)
     result = asyncio.get_event_loop().run_until_complete(
         _host_replay(replay_path, ai, realtime, portconfig, base_build, data_version, observed_id)

sc2/pixel_map.py

@@ -18,9 +18,9 @@ def __init__(self, proto, in_bits: bool = False) -> None:
         # Used for copying pixelmaps
         self._in_bits: bool = in_bits
 
-        assert self.width * self.height == (8 if in_bits else 1) * len(
-            self._proto.data
-        ), f"{self.width * self.height} {(8 if in_bits else 1)*len(self._proto.data)}"
+        assert self.width * self.height == (8 if in_bits else 1) * len(self._proto.data), (
+            f"{self.width * self.height} {(8 if in_bits else 1) * len(self._proto.data)}"
+        )
         buffer_data = np.frombuffer(self._proto.data, dtype=np.uint8)
         if in_bits:
             buffer_data = np.unpackbits(buffer_data)
@@ -52,9 +52,9 @@ def __setitem__(self, pos: tuple[int, int], value: int) -> None:
         """Example usage: self._game_info.pathing_grid[Point2((20, 20))] = 255"""
         assert 0 <= pos[0] < self.width, f"x is {pos[0]}, self.width is {self.width}"
         assert 0 <= pos[1] < self.height, f"y is {pos[1]}, self.height is {self.height}"
-        assert (
-            0 <= value <= 254 * self._in_bits + 1
-        ), f"value is {value}, it should be between 0 and {254 * self._in_bits + 1}"
+        assert 0 <= value <= 254 * self._in_bits + 1, (
+            f"value is {value}, it should be between 0 and {254 * self._in_bits + 1}"
+        )
         assert isinstance(value, int), f"value is of type {type(value)}, it should be an integer"
         self.data_numpy[pos[1], pos[0]] = value
 

sc2/player.py

@@ -55,7 +55,7 @@ def __init__(self, race, name: str | None = None, fullscreen: bool = False) -> N
 
     def __str__(self) -> str:
         if self.name is not None:
-            return f"Human({self.race._name_}, name={self.name !r})"
+            return f"Human({self.race._name_}, name={self.name!r})"
         return f"Human({self.race._name_})"
 
 
@@ -71,7 +71,7 @@ def __init__(self, race, ai, name: str | None = None, fullscreen: bool = False)
 
     def __str__(self) -> str:
         if self.name is not None:
-            return f"Bot {self.ai.__class__.__name__}({self.race._name_}), name={self.name !r})"
+            return f"Bot {self.ai.__class__.__name__}({self.race._name_}), name={self.name!r})"
         return f"Bot {self.ai.__class__.__name__}({self.race._name_})"