TEST

.github/workflows/push-to-pypi.yml

@@ -1,24 +1,35 @@
 on:
+  workflow_dispatch:
+    inputs:
+      confirmation:
+        description: 'I want to manually trigger a PyPi push, without publishing a GitHub release (not recommended!)'
+        required: true
+        type: boolean
   release:
     types: [created]
 
 jobs:
   deploy:
+    name: Upload release to PyPI
     runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/coc.py
+    permissions:
+      id-token: write
+    if: github.event_name != 'workflow_dispatch' || (github.event_name == 'workflow_dispatch' &&  github.event.inputs.confirmation != 'false')
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v5
       with:
         python-version: '3.x'
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
-        pip install setuptools wheel twine
-    - name: Build and publish
-      env:
-        TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
-        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+        pip install --upgrade pip
+        pip install --upgrade build
+    - name: Build
       run: |
-        python setup.py sdist bdist_wheel
-        twine upload dist/*
+        python -m build
+    - name: Publish package distributions to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1

.github/workflows/tests.yml

@@ -31,10 +31,7 @@ jobs:
         DEV_SITE_EMAIL: ${{ secrets.DEV_SITE_EMAIL }}
         DEV_SITE_PASSWORD: ${{ secrets.DEV_SITE_PASSWORD }}
         DISCORD_BOT_TOKEN: ${{ secrets.DISCORD_BOT_TOKEN }}
-        LINKS_API_USERNAME: ${{ secrets.LINKS_API_USERNAME }}
-        LINKS_API_PASSWORD: ${{ secrets.LINKS_API_PASSWORD }}
         RUNNING_TESTS: true
       run: |
-        python -m examples.discord_links
         python -m examples.events_example
         python -m examples.war_logs

.readthedocs.yml

@@ -2,15 +2,16 @@ version: 2
 formats: []
 
 build:
-  image: latest
+  os: ubuntu-22.04
+  tools:
+    python: "3.7"
 
 sphinx:
   configuration: docs/conf.py
   fail_on_warning: false
   builder: html
 
 python:
-  version: 3.7
   install:
     - method: pip
       path: .

README.rst

@@ -55,7 +55,7 @@ This example will get a player with a certain tag, and search for 5 clans with a
         async with coc.Client() as coc_client:
             try:
                 await coc_client.login("email", "password")
-            except coc.invalidcredentials as error:
+            except coc.InvalidCredentials as error:
                 exit(error)
 
             player = await coc_client.get_player("tag")

coc/__init__.py

@@ -22,22 +22,27 @@
 SOFTWARE.
 """
 
-__version__ = "2.4.0"
+__version__ = "3.8.2"
 
 from .abc import BasePlayer, BaseClan
 from .clans import RankedClan, Clan
 from .client import Client
 from .events import PlayerEvents, ClanEvents, WarEvents, EventsClient, ClientEvents
 from .enums import (
+    PlayerHouseElementType,
     Resource,
     Role,
     WarRound,
     ACHIEVEMENT_ORDER,
     BUILDER_TROOPS_ORDER,
     HERO_ORDER,
     PETS_ORDER,
+    ELIXIR_TROOP_ORDER,
+    DARK_ELIXIR_TROOP_ORDER,
     HOME_TROOP_ORDER,
     SIEGE_MACHINE_ORDER,
+    ELIXIR_SPELL_ORDER,
+    DARK_ELIXIR_SPELL_ORDER,
     SPELL_ORDER,
     SUPER_TROOP_ORDER,
     UNRANKED_LEAGUE_DATA,
@@ -53,8 +58,7 @@
     GatewayError,
     PrivateWarLog,
 )
-from .login import login, login_with_keys
-from .hero import Hero, Pet
+from .hero import Equipment, Hero, Pet
 from .http import BasicThrottler, BatchThrottler, HTTPClient
 from .iterators import (
     ClanIterator,
@@ -73,10 +77,11 @@
     LegendStatistics,
     LoadGameData,
     Location,
+    PlayerHouseElement,
     Timestamp,
     TimeDelta,
     Label,
-    WarLeague,
+    BaseLeague
 )
 from .players import Player, ClanMember, RankedPlayer
 from .player_clan import PlayerClan

coc/abc.py

@@ -171,6 +171,12 @@ def __init__(self, data, townhall):
 
         self._townhall = townhall
 
+        # copies for a static hash
+        self.__name = data['name']
+        self.__level = data['level']
+        self.__village = data['village']
+        self.__is_active = data.get("superTroopIsActive")
+
     def __repr__(self):
         attrs = [
             ("name", self.name),
@@ -180,20 +186,29 @@ def __repr__(self):
         return "<%s %s>" % (
             self.__class__.__name__, " ".join("%s=%r" % t for t in attrs),)
 
+    def __eq__(self, other):
+        return self.name == other.name and self.level == other.level \
+            and self.village == other.village and self.is_active == other.is_active
+
+    def __hash__(self):
+        return hash((self.__name, self.__level, self.__village, self.__is_active))
+
+
     @classmethod
-    def _load_json_meta(cls, troop_meta, id, name, lab_to_townhall):
+    def _load_json_meta(cls, json_meta: dict, id, name: str, lab_to_townhall):
         cls.id = int(id)
         cls.name = name
         cls.lab_to_townhall = 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.hitpoints = try_enum(UnitStat, troop_meta.get("Hitpoints"))
+        levels_available = [key for key in json_meta.keys() if key.isnumeric()]
+
+        cls.ground_target = json_meta.get("GroundTargets", True)
+        cls.range = try_enum(UnitStat, [json_meta.get(level).get("AttackRange") for level in levels_available])
+        cls.dps = try_enum(UnitStat, [json_meta.get(level).get("DPS") for level in levels_available])
+        cls.hitpoints = try_enum(UnitStat, [json_meta.get(level).get("Hitpoints") for level in levels_available])
 
         # get production building
-        production_building = troop_meta.get("ProductionBuilding", [None])[0]
+        production_building = json_meta.get("ProductionBuilding")
         if production_building == "Barrack":
             cls.is_elixir_troop = True
         elif production_building == "Dark Elixir Barrack":
@@ -213,75 +228,79 @@ def _load_json_meta(cls, troop_meta, id, name, lab_to_townhall):
 
         # without production_building, it is a hero
         if not production_building:
-            laboratory_levels = troop_meta.get("LaboratoryLevel")
+            laboratory_levels = [json_meta.get(level).get("LaboratoryLevel") for level in levels_available]
         else:
-            # it is a troop or spell or siege
             prod_unit = buildings.get(production_building)
             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]
+                min_prod_unit_level = json_meta.get("BarrackLevel", None)
                 # there are some special troops, which have no BarrackLevel attribute
                 if not min_prod_unit_level:
-                    laboratory_levels = troop_meta.get("LaboratoryLevel")
+                    laboratory_levels = [json_meta.get(level).get("LaboratoryLevel") for level in levels_available]
                 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]
+                    #get the townhall level of the spot where prod building level is equal to the one of the unit
+                    min_th_level = prod_unit.get(str(min_prod_unit_level)).get("TownHallLevel", 0)
                     # 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]
+                    [first_lab_level] = [lab_level for lab_level, th_level in lab_to_townhall.items() if th_level == 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"):
+                    for lab_level in [json_meta.get(level).get("LaboratoryLevel", 1) for level in levels_available]:
                         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
+                min_prod_unit_level = json_meta.get("1").get("LaboratoryLevel")
 
                 # 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]
+                min_th_level = prod_unit.get(str(min_prod_unit_level)).get("TownHallLevel", 0)
+
                 # 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]
+                [first_lab_level] = [lab_level for lab_level, th_level in lab_to_townhall.items() if th_level == 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"):
+                for lab_level in [json_meta.get(level).get("LaboratoryLevel") for level in levels_available]:
                     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)
-        cls.speed = try_enum(UnitStat, troop_meta.get("Speed"))
+        cls.housing_space = json_meta.get("HousingSpace", 0)
+
+        cls.speed = try_enum(UnitStat, [json_meta.get(level).get("Speed") for level in levels_available])
         cls.level = cls.dps and UnitStat(range(1, len(cls.dps) + 1))
 
-        # 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._is_home_village = False if troop_meta.get("VillageType") else True
+        cls.upgrade_cost = try_enum(UnitStat, [json_meta.get(level).get("UpgradeCost") for level in levels_available])
+        cls.upgrade_resource = Resource(value=json_meta.get("UpgradeResource"))
+        upgrade_times = [
+            TimeDelta(hours=json_meta.get(level, {}).get("UpgradeTimeH"))
+            for level in levels_available
+            if json_meta.get(level, {}).get("UpgradeTimeH") is not None
+        ]
+        cls.upgrade_time = try_enum(UnitStat, upgrade_times)
+
+        cls._is_home_village = False if json_meta.get("VillageType") else True
         cls.village = "home" if cls._is_home_village else "builderBase"
 
-        # spells and troops
-        cls.training_cost = try_enum(UnitStat, troop_meta.get("TrainingCost"))
-        cls.training_time = try_enum(UnitStat, troop_meta.get("TrainingTime"))
+        cls.training_time = TimeDelta(seconds=json_meta.get("TrainingTime"))
 
         # 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") or laboratory_levels)
-        cls.regeneration_time = try_enum(
-            UnitStat, [TimeDelta(minutes=value) for value in troop_meta.get("RegenerationTimeMinutes", [])]
-        )
+        cls.ability_time = try_enum(UnitStat, [json_meta.get(level).get("AbilityTime") for level in levels_available])
+        cls.ability_troop_count = try_enum(UnitStat, [json_meta.get(level).get("AbilitySummonTroopCount") for level in levels_available])
+
+        required_townhall_levels = [json_meta.get(level).get("RequiredTownHallLevel") for level in levels_available]
+        cls.required_th_level = try_enum(UnitStat, required_townhall_levels if any(required_townhall_levels) else laboratory_levels)
+
+        regeneration_times = [
+            TimeDelta(minutes=json_meta.get(level, {}).get("RegenerationTimeMinutes"))
+            for level in levels_available
+            if json_meta.get(level, {}).get("RegenerationTimeMinutes") is not None
+        ]
+        cls.regeneration_time = try_enum(UnitStat, regeneration_times)
 
         cls.is_loaded = True
         return cls
@@ -326,11 +345,13 @@ class DataContainerHolder:
     def __init__(self):
         self.loaded = False
 
-    def _load_json(self, object_ids, english_aliases, lab_to_townhall):
+    def _load_json(self, english_aliases, lab_to_townhall):
         with open(self.FILE_PATH) as fp:
             data = ujson.load(fp)
 
+        id = 2000
         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
@@ -340,8 +361,16 @@ 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 meta.get("DisableProduction") and "pets" not in str(self.FILE_PATH):
+                continue
+
+            # ignore deprecated content
+            if meta.get("Deprecated"):
+                continue
+
+            #hacky but the aliases convert so that isnt great
+            IGNORED_PETS = ["Unused", "PhoenixEgg"]
+            if "pets" in str(self.FILE_PATH) and supercell_name in IGNORED_PETS:
                 continue
 
             # A bit of a hacky way to create a "copy" of a new Troop object that hasn't been initiated yet.
@@ -350,11 +379,11 @@ def _load_json(self, object_ids, english_aliases, lab_to_townhall):
                             dict(self.data_object.__dict__))
             new_item._load_json_meta(
                 meta,
-                id=object_ids.get(supercell_name, c),
-                name=english_aliases[meta["TID"][0]][0],
+                id=id,
+                name=english_aliases[meta.get("TID")],
                 lab_to_townhall=lab_to_townhall,
             )
-
+            id += 1
             self.items.append(new_item)
             self.item_lookup[new_item.name] = new_item