Merge pull request #169 from mathsman5133/g7_2.3.0

Release 2.3.0

Author: doluk

README.rst

@@ -141,7 +141,9 @@ These can be installed with:
 
 .. code:: sh
 
-    pip install .[docs]
+    pip install -r doc_requirements.txt
+    cd docs
+    make html
 
 If you wish to run linting, pylint, black and flake8 have been setup and can be run with:
 

coc/__init__.py

@@ -22,7 +22,7 @@
 SOFTWARE.
 """
 
-__version__ = "2.2.3"
+__version__ = "2.3.0"
 
 from .abc import BasePlayer, BaseClan
 from .clans import RankedClan, Clan
@@ -35,7 +35,7 @@
     ACHIEVEMENT_ORDER,
     BUILDER_TROOPS_ORDER,
     HERO_ORDER,
-    HERO_PETS_ORDER,
+    PETS_ORDER,
     HOME_TROOP_ORDER,
     SIEGE_MACHINE_ORDER,
     SPELL_ORDER,
@@ -66,7 +66,9 @@
 from .miscmodels import (
     Achievement,
     Badge,
+    CapitalDistrict,
     Icon,
+    GoldPassSeason,
     League,
     LegendStatistics,
     LoadGameData,
@@ -78,6 +80,7 @@
 )
 from .players import Player, ClanMember, RankedPlayer
 from .player_clan import PlayerClan
+from .raid import RaidClan, RaidMember, RaidLogEntry, RaidDistrict, RaidAttack
 from .spell import Spell
 from .troop import Troop
 from .war_clans import WarClan, ClanWarLeagueClan

coc/abc.py

@@ -25,19 +25,21 @@
 from pathlib import Path
 from typing import AsyncIterator, Any, Dict, Type, Optional, TYPE_CHECKING
 
-from .enums import Resource
+from .enums import PETS_ORDER, Resource
 from .miscmodels import try_enum, Badge, TimeDelta
 from .iterators import PlayerIterator
 from .utils import CaseInsensitiveDict, UnitStat, _get_maybe_first
 
 if TYPE_CHECKING:
     from .players import Player
 
-BUILDING_FILE_PATH = Path(__file__).parent.joinpath(Path("static/buildings.json"))
+BUILDING_FILE_PATH = Path(__file__).parent.joinpath(
+    Path("static/buildings.json"))
 
 
 class BaseClan:
-    """An ABC that implements some common operations on clans, regardless of type.
+    """
+    Abstract data class that represents base Clan objects
 
     Attributes
     ----------
@@ -50,48 +52,51 @@ class BaseClan:
     level: :class:`int`
         The clan's level.
     """
+    __slots__ = ("tag", "name", "_client", "badge", "level", "_response_retry", "_raw_data")
 
-    __slots__ = ("tag", "name", "_client", "badge", "level", "_response_retry")
+    def __init__(self, *, data, client, **kwargs):
+        self._client = client
+
+        self._response_retry = data.get("_response_retry")
+        self.tag = data.get("tag")
+        self.name = data.get("name")
+        self.badge = try_enum(Badge, data=data.get("badgeUrls"),
+                              client=self._client)
+        self.level = data.get("clanLevel")
+        self._raw_data = data if client and client.raw_attribute else None
 
     def __str__(self):
         return self.name
 
     def __repr__(self):
-        return "<%s tag=%s name=%s>" % (self.__class__.__name__, self.tag, self.name)
+        return f"<{self.__class__.__name__} tag={self.tag} name={self.name}>"
 
     def __eq__(self, other):
         return isinstance(other, BaseClan) and self.tag == other.tag
 
-    def __init__(self, *, data, client, **_):
-        self._client = client
-
-        self._response_retry = data.get("_response_retry")
-        self.tag = data.get("tag")
-        self.name = data.get("name")
-        self.badge = try_enum(Badge, data=data.get("badgeUrls"), client=self._client)
-        self.level = data.get("clanLevel")
-
     @property
     def share_link(self) -> str:
-        """:class:`str` - A formatted link to open the clan in-game"""
-        return "https://link.clashofclans.com/en?action=OpenClanProfile&tag=%23{}".format(self.tag.strip("#"))
+        """str: A formatted link to open the clan in-game"""
+        return f"https://link.clashofclans.com/en?action=OpenClanProfile&tag=%23{self.tag.strip('#')}"
 
     @property
     def members(self):
         # pylint: disable=missing-function-docstring
         return NotImplemented
 
-    def get_detailed_members(self, cls: Type["Player"] = None, load_game_data: bool = None) -> AsyncIterator["Player"]:
+    def get_detailed_members(self, cls: Type["Player"] = None,
+                             load_game_data: bool = None) -> AsyncIterator["Player"]:
         """Get detailed player information for every player in the clan.
 
-        This returns a :class:`PlayerIterator` which fetches all player tags in the clan in parallel.
+        This returns a :class:`PlayerIterator` which fetches all player
+        tags in the clan in parallel.
 
         Example
         ---------
 
         .. code-block:: python3
 
-            clan = await client.get_clan('tag')
+            clan = await client.get_clan(clan_tag)
 
             async for player in clan.get_detailed_members():
                 print(player.name)
@@ -125,41 +130,37 @@ class BasePlayer:
         The player's name
     """
 
-    __slots__ = ("tag", "name", "_client", "_response_retry")
+    __slots__ = ("tag", "name", "_client", "_response_retry", "_raw_data")
 
     def __str__(self):
         return self.name
 
     def __repr__(self):
-        return "<%s tag=%s name=%s>" % (self.__class__.__name__, self.tag, self.name,)
+        return f"<{self.__class__.__name__} tag={self.tag} name={self.name}>"
 
     def __eq__(self, other):
         return isinstance(other, BasePlayer) and self.tag == other.tag
 
     def __init__(self, *, data, client, **_):
         self._client = client
         self._response_retry = data.get("_response_retry")
-
+        self._raw_data = data if client and client.raw_attribute else None
         self.tag = data.get("tag")
         self.name = data.get("name")
 
     @property
     def share_link(self) -> str:
         """:class:`str` - A formatted link to open the player in-game"""
-        return "https://link.clashofclans.com/en?action=OpenPlayerProfile&tag=%23{}".format(self.tag.strip("#"))
+        return f"https://link.clashofclans.com/en?action=OpenPlayerProfile&tag=%23{self.tag.strip('#')}"
 
 
 class DataContainerMetaClass(type):
-    def __repr__(cls):
-        attrs = [
-            ("name", cls.name),
-            ("id", cls.id),
-        ]
-        return "<%s %s>" % (cls.__name__, " ".join("%s=%r" % t for t in attrs),)
+    pass
 
 
 class DataContainer(metaclass=DataContainerMetaClass):
     lab_to_townhall: Dict[int, int]
+    name: str
 
     def __init__(self, data, townhall):
         self.name: str = data["name"]
@@ -176,7 +177,8 @@ def __repr__(self):
             ("level", self.level),
             ("is_active", self.is_active),
         ]
-        return "<%s %s>" % (self.__class__.__name__, " ".join("%s=%r" % t for t in attrs),)
+        return "<%s %s>" % (
+            self.__class__.__name__, " ".join("%s=%r" % t for t in attrs),)
 
     @classmethod
     def _load_json_meta(cls, troop_meta, id, name, lab_to_townhall):
@@ -186,7 +188,8 @@ def _load_json_meta(cls, troop_meta, id, name, lab_to_townhall):
 
         cls.range = try_enum(UnitStat, troop_meta.get("AttackRange"))
         cls.dps = try_enum(UnitStat, troop_meta.get("DPS"))
-        cls.ground_target = _get_maybe_first(troop_meta, "GroundTargets", default=True)
+        cls.ground_target = _get_maybe_first(troop_meta, "GroundTargets",
+                                             default=True)
         cls.hitpoints = try_enum(UnitStat, troop_meta.get("Hitpoints"))
 
         # get production building
@@ -201,32 +204,58 @@ def _load_json_meta(cls, troop_meta, id, name, lab_to_townhall):
             cls.is_elixir_spell = True
         elif production_building == "Mini Spell Factory":
             cls.is_dark_spell = True
+        elif name in PETS_ORDER:
+            production_building = "Pet Shop"
 
         # load buildings
         with open(BUILDING_FILE_PATH) as fp:
             buildings = ujson.load(fp)
 
-        # without production_building, it is a hero or pet
+        # without production_building, it is a hero
         if not production_building:
             laboratory_levels = troop_meta.get("LaboratoryLevel")
         else:
-            # it is a troop or spell
+            # it is a troop or spell or siege
             prod_unit = buildings.get(production_building)
-            min_prod_unit_level = troop_meta.get("BarrackLevel", [None, ])[0]
-            # there are some special troops, which have no BarrackLevel attribute
-            if not min_prod_unit_level:
-                laboratory_levels = troop_meta.get("LaboratoryLevel")
-            else:
+            if production_building in ("SiegeWorkshop", "Spell Forge", "Mini Spell Factory",
+                                       "Dark Elixir Barrack", "Barrack", "Barrack2"):
+                min_prod_unit_level = troop_meta.get("BarrackLevel", [None, ])[0]
+                # there are some special troops, which have no BarrackLevel attribute
+                if not min_prod_unit_level:
+                    laboratory_levels = troop_meta.get("LaboratoryLevel")
+                else:
+                    # get the min th level were we can unlock by the required level of the production building
+                    min_th_level = [th for i, th in
+                                    enumerate(prod_unit["TownHallLevel"], start=1)
+                                    if i == min_prod_unit_level]
+                    # map the min th level to a lab level
+                    [first_lab_level] = [lab_level for lab_level, th_level in
+                                         lab_to_townhall.items()
+                                         if th_level in min_th_level]
+                    # the first_lab_level is the lowest possible (there are some inconsistencies with siege machines)
+                    # To handle them properly, replacing all lab_level lower than first_lab_level with first_lab_level
+                    laboratory_levels = []
+                    for lab_level in troop_meta.get("LaboratoryLevel"):
+                        laboratory_levels.append(max(lab_level, first_lab_level))
+            elif production_building == "Pet Shop":
+                min_prod_unit_level = troop_meta.get("LaboratoryLevel", [None, ])[0]
+                # there are some special troops, which have no BarrackLevel attribute
+
                 # get the min th level were we can unlock by the required level of the production building
-                min_th_level = [th for i, th in enumerate(prod_unit["TownHallLevel"], start=1)
+                min_th_level = [th for i, th in
+                                enumerate(prod_unit["TownHallLevel"], start=1)
                                 if i == min_prod_unit_level]
                 # map the min th level to a lab level
-                [first_lab_level] = [lab_level for lab_level, th_level in lab_to_townhall.items()
+                [first_lab_level] = [lab_level for lab_level, th_level in
+                                     lab_to_townhall.items()
                                      if th_level in min_th_level]
                 # the first_lab_level is the lowest possible (there are some inconsistencies with siege machines)
                 # To handle them properly, replacing all lab_level lower than first_lab_level with first_lab_level
-                laboratory_levels = [x if x > first_lab_level else first_lab_level
-                                     for x in troop_meta.get("LaboratoryLevel")]
+                laboratory_levels = []
+                for lab_level in troop_meta.get("LaboratoryLevel"):
+                    laboratory_levels.append(max(lab_level, first_lab_level))
+            else:
+                return
 
         cls.lab_level = try_enum(UnitStat, laboratory_levels)
         cls.housing_space = _get_maybe_first(troop_meta, "HousingSpace", default=0)
@@ -236,7 +265,9 @@ def _load_json_meta(cls, troop_meta, id, name, lab_to_townhall):
         # all 3
         cls.upgrade_cost = try_enum(UnitStat, troop_meta.get("UpgradeCost"))
         cls.upgrade_resource = Resource(value=troop_meta["UpgradeResource"][0])
-        cls.upgrade_time = try_enum(UnitStat, [TimeDelta(hours=hours) for hours in troop_meta.get("UpgradeTimeH", [])])
+        cls.upgrade_time = try_enum(UnitStat,
+                                    [TimeDelta(hours=hours) for hours in
+                                     troop_meta.get("UpgradeTimeH", [])])
         cls._is_home_village = False if troop_meta.get("VillageType") else True
         cls.village = "home" if cls._is_home_village else "builderBase"
 
@@ -247,8 +278,10 @@ def _load_json_meta(cls, troop_meta, id, name, lab_to_townhall):
         # only heroes
         cls.ability_time = try_enum(UnitStat, troop_meta.get("AbilityTime"))
         cls.ability_troop_count = try_enum(UnitStat, troop_meta.get("AbilitySummonTroopCount"))
-        cls.required_th_level = try_enum(UnitStat, troop_meta.get("RequiredTownHallLevel"))
-        cls.regeneration_time = try_enum(UnitStat, [TimeDelta(minutes=value) for value in troop_meta.get("RegenerationTimeMinutes", [])])
+        cls.required_th_level = try_enum(UnitStat, troop_meta.get("RequiredTownHallLevel") or laboratory_levels)
+        cls.regeneration_time = try_enum(
+            UnitStat, [TimeDelta(minutes=value) for value in troop_meta.get("RegenerationTimeMinutes", [])]
+        )
 
         cls.is_loaded = True
         return cls
@@ -297,7 +330,7 @@ def _load_json(self, object_ids, english_aliases, lab_to_townhall):
         with open(self.FILE_PATH) as fp:
             data = ujson.load(fp)
 
-        for supercell_name, meta in data.items():
+        for c, [supercell_name, meta] in enumerate(data.items()):
             # Not interested if it doesn't have a TID, since it likely isn't a real troop.
             if not meta.get("TID"):
                 continue
@@ -307,14 +340,17 @@ def _load_json(self, object_ids, english_aliases, lab_to_townhall):
                 continue
 
             # SC game files have "DisableProduction" true for all pet objects, which we want
-            if "DisableProduction" in meta and "pets" not in str(self.FILE_PATH):
+            if "DisableProduction" in meta and "pets" not in str(
+                    self.FILE_PATH):
                 continue
 
-            # Little bit of a hacky way to create a "copy" of a new Troop object that hasn't been initiated yet.
-            new_item = type(self.data_object.__name__, self.data_object.__bases__, dict(self.data_object.__dict__))
+            # A bit of a hacky way to create a "copy" of a new Troop object that hasn't been initiated yet.
+            new_item = type(self.data_object.__name__,
+                            self.data_object.__bases__,
+                            dict(self.data_object.__dict__))
             new_item._load_json_meta(
                 meta,
-                id=object_ids.get(supercell_name, 0),
+                id=object_ids.get(supercell_name, c),
                 name=english_aliases[meta["TID"][0]][0],
                 lab_to_townhall=lab_to_townhall,
             )
@@ -325,8 +361,8 @@ def _load_json(self, object_ids, english_aliases, lab_to_townhall):
         self.loaded = True
 
     def load(
-        self, data, townhall: int, default: Type[DataContainer] = None, load_game_data: bool = True
-    ) -> DataContainer:
+            self, data: dict, townhall: int, default: Type[DataContainer] = None,
+            load_game_data: bool = True) -> DataContainer:
         if load_game_data is True:
             try:
                 item = self.item_lookup[data["name"]]