Merge remote-tracking branch 'origin/3.6.1' into 3.6.1

Author: doluk

coc/__init__.py

@@ -22,7 +22,7 @@
 SOFTWARE.
 """
 
-__version__ = "3.6.1"
+__version__ = "3.7.0"
 
 from .abc import BasePlayer, BaseClan
 from .clans import RankedClan, Clan

coc/enums.py

@@ -23,6 +23,7 @@
 """
 from enum import Enum
 
+
 class ExtendedEnum(Enum):
     """An Enum class that allows for the `__str__` method to be implemented."""
     def __str__(self):
@@ -61,10 +62,8 @@ class PlayerHouseElementType(ExtendedEnum):
     @property
     def in_game_name(self) -> str:
         """Get a neat client-facing string value for the element type."""
-        lookup = {PlayerHouseElementType.ground: "Ground", PlayerHouseElementType.roof: "Roof",
-                  PlayerHouseElementType.foot: "Foot", PlayerHouseElementType.deco: "Decoration",
-                  PlayerHouseElementType.walls: "Walls"}
-        return lookup[self]
+        lookup = {"ground": "Ground", "roof": "Roof", "foot": "Foot", "decoration": "Decoration", "walls": "Walls"}
+        return lookup[self.value]
 
 
 class Role(ExtendedEnum):
@@ -78,8 +77,8 @@ class Role(ExtendedEnum):
     @property
     def in_game_name(self) -> str:
         """Get a neat client-facing string value for the role."""
-        lookup = {Role.member: "Member", Role.elder: "Elder", Role.co_leader: "Co-Leader", Role.leader: "Leader"}
-        return lookup[self]
+        lookup = {"member": "Member", "admin": "Elder", "coLeader": "Co-Leader", "leader": "Leader"}
+        return lookup[self.value]
 
 
 class WarRound(ExtendedEnum):
@@ -90,16 +89,23 @@ class WarRound(ExtendedEnum):
     def __str__(self):
         return self.name
 
+    @property
+    def in_game_name(self) -> str:
+        lookup = ["Previous War", "Current War", "Current Preparation"]
+        return lookup[self.value]
+
+
 class BattleModifier(ExtendedEnum):
     """Enum to map the type of battle modifiers."""
-    none = "None"
+    none = "none"
     hard_mode = "hardMode"
 
     @property
     def in_game_name(self) -> str:
         """Get a neat client-facing string value for the battle modifier."""
-        lookup = {BattleModifier.none: "None", BattleModifier.hard_mode: "Hard Mode"}
-        return lookup[self]
+        lookup = {"none": "None", "hardMode": "Hard Mode"}
+        return lookup[self.value]
+
 
 class WarState(ExtendedEnum):
     """Enum to map the state of the war.
@@ -112,9 +118,21 @@ class WarState(ExtendedEnum):
     @property
     def in_game_name(self) -> str:
         """Get a neat client-facing string value for the war state."""
-        lookup = {WarState.not_in_war: "Not in War", WarState.preparation: "Preparation",
-                  WarState.in_war: "In War", WarState.war_ended: "War Ended"}
-        return lookup[self]
+        lookup = {"notInWar": "Not in War", "preparation": "Preparation", "inWar": "In War", "warEnded": "War Ended"}
+        return lookup[self.value]
+
+
+class WarResult(ExtendedEnum):
+    """Enum to map the result of the war"""
+    win = "win"
+    lose = "lose"
+    tie = "tie"
+
+    @property
+    def in_game_name(self) -> str:
+        """Get a neat client-facing string value for the war state."""
+        lookup = {"win": "Win", "lose": "Lose", "tie": "Tie"}
+        return lookup[self.value]
 
 
 class Resource(ExtendedEnum):
@@ -130,10 +148,10 @@ class Resource(ExtendedEnum):
     @property
     def in_game_name(self) -> str:
         """Get a neat client-facing string value for the resource."""
-        lookup = {Resource.elixir: "Elixir", Resource.builder_elixir: "Builder Elixir",
-                  Resource.dark_elixir: "Dark Elixir", Resource.gold: "Gold", Resource.builder_gold: "Builder Gold",
-                  Resource.shiny_ore: "Shiny Ore", Resource.glowy_ore: "Glowy Ore", Resource.starry_ore: "Starry Ore"}
-        return lookup[self]
+        lookup = {"Elixir": "Elixir", "Elixir2": "Builder Elixir",
+                  "DarkElixir": "Dark Elixir", "Gold": "Gold", "Gold2": "Builder Gold",
+                  "CommonOre": "Shiny Ore", "RareOre": "Glowy Ore", "EpicOre": "Starry Ore"}
+        return lookup[self.value]
 
 
 ELIXIR_TROOP_ORDER = [

coc/miscmodels.py

@@ -25,14 +25,16 @@
 from typing import Any, Type, TypeVar, Optional
 
 import coc
-from .enums import PlayerHouseElementType
+from .enums import ExtendedEnum, PlayerHouseElementType
 from .utils import from_timestamp
 
 T = TypeVar("T")
 
 
 def try_enum(_class: Type[T], data: Any, **kwargs) -> Optional[T]:
     """Helper function to create a class from the given data."""
+    if issubclass(_class, ExtendedEnum):
+        return data and _class(data)
     return data and _class(data=data, **kwargs)
 
 

coc/wars.py

@@ -28,7 +28,7 @@
 
 from typing import AsyncIterator, List, Optional, Type, TYPE_CHECKING, Union
 
-from .enums import BattleModifier, WarRound, WarState
+from .enums import BattleModifier, WarResult, WarRound, WarState
 from .iterators import LeagueWarIterator
 from .miscmodels import try_enum, Timestamp
 from .utils import cached_property, get
@@ -112,7 +112,7 @@ def _from_data(self, data: dict) -> None:
         self.start_time = try_enum(Timestamp, data=data_get("startTime"))
         self.end_time = try_enum(Timestamp, data=data_get("endTime"))
         self.war_tag: str = data_get("tag")
-        self.battle_modifier: BattleModifier = try_enum(BattleModifier, data=str(data_get('battleModifier')))
+        self.battle_modifier: BattleModifier = try_enum(BattleModifier, data=data_get('battleModifier', 'none'))
         if data_get("attacksPerMember") is None or self.is_cwl:
             self.attacks_per_member: int = 1
         else:
@@ -323,7 +323,7 @@ class ClanWarLogEntry:
     Attributes
     ----------
     result:
-        :class:`str`: The result of the war - ``win`` or ``loss``
+        :class:`WarResult`: The result of the war - ``win``, ``lose`` or ``tie``
     end_time:
         :class:`Timestamp`: The :class:`Timestamp` that the war ended at.
     team_size:
@@ -334,11 +334,13 @@ class ClanWarLogEntry:
         :class:`WarClan`: The opposition clan.
     attacks_per_member:
         :class:`int`: The number of attacks each member had this war.
+    battle_modifier:
+        :class:`BattleModifier`: The battle modifier for this war.
     """
 
     __slots__ = (
         "result", "end_time", "team_size", "clan", "opponent", "_client",
-        "attacks_per_member", "_raw_data", "_response_retry")
+        "attacks_per_member", "battle_modifier", "_raw_data", "_response_retry")
 
     def __init__(self, *, data, client, **kwargs):
         self._client = client
@@ -360,12 +362,13 @@ def __eq__(self, other) -> bool:
     def _from_data(self, data: dict) -> None:
         data_get = data.get
 
-        self.result: str = data_get("result")
+        self.result: WarResult = try_enum(WarResult, data=data_get("result"))
         self.end_time = try_enum(Timestamp, data=data_get("endTime"))
         self.team_size: int = data_get("teamSize")
 
         self.clan = self._fake_load_clan(data_get("clan"))
         self.opponent = self._fake_load_clan(data_get("opponent"))
+        self.battle_modifier: BattleModifier = try_enum(BattleModifier, data=data_get('battleModifier', 'none'))
 
         if data_get("attacksPerMember") is None and self.is_league_entry:
             self.attacks_per_member: int = 1

docs/conf.py

@@ -15,7 +15,7 @@
 project = 'coc'
 copyright = '2022, mathsman5133'
 author = 'mathsman5133'
-release = '3.6.1'
+release = '3.7.0'
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

docs/miscellaneous/changelog.rst

@@ -7,19 +7,20 @@ Changelog
 This page keeps a fairly detailed, human readable version
 of what has changed, and whats new for each version of the lib.
 
-v3.6.1
+v3.7.0
 ------
 
 Additions:
 ~~~~~~~~~~
 - Added inheritance of classes into the docs to make it easier to see what classes inherit from others.
-- Added the new `BattleModifier` to the `ClanWar` class.
+- Added the new :class:`BattleModifier` to :attr:`ClanWar.battle_modifier` and :class:`ClanWarLogEntry.battle_modifier`.
 - Added the new troop and equipment in June 2024 update to the static data.
 
 Changes:
 ~~~~~~~~
-- Changed the way the `ClanWar` class handles the `state` attribute. It now returns a `WarState` enumeration object
-  instead of a string to allow better type hinting and easier comparison.
+- Changed the way the :class:`ClanWar` and :class:`ClanWarLogEntry` classes handles the :attr:`state` and :attr:`result`
+  attribute, respectively. It now returns a :class:`WarState`/:class:`WarResult` enumeration object instead of a string
+  to allow better type hinting and easier comparison.
 - Updated the static data to reflect the June 2024 update changes.
 
 v3.6.0

pyproject.toml

@@ -7,7 +7,7 @@ name = "coc.py"
 authors = [{ name = "mathsman5133" }]
 maintainers = [{ name = "majordoobie" }, { name = "MagicTheDev" }, { name = "Kuchenmampfer" },
     { name = "lukasthaler"}, { name = "doluk"}]
-version = "3.6.1"
+version = "3.7.0"
 description = "A python wrapper for the Clash of Clans API"
 requires-python = ">=3.7.3"
 readme = "README.rst"