Bump version: 0.21.4.1 → 0.21.4.2

* memory-optimisation:
  Company cleanup optimisation
  JSON.dump sort_keys parameter throwing mysterious errors
  Fixed memory leak in Battle and MyCompanies classes

Makefile

@@ -88,9 +88,3 @@ dist: clean ## builds source and wheel package
 
 install: clean ## install the package to the active Python's site-packages
 	python setup.py install
-
-setcommit:
-	bash set_commit_id.sh
-# 	commit=`git log -1 --pretty=format:%h`
-# 	sed -i.bak -E "s|COMMIT_ID = \".+\"|COMMIT_ID = \"$(commit)\"|g" erepublik/utils.py
-# 	mv erepublik/utils.py.bak erepublik/utils.py

erepublik/__init__.py

@@ -4,7 +4,7 @@
 
 __author__ = """Eriks Karls"""
 __email__ = 'eriks@72.lv'
-__version__ = '0.21.1'
+__version__ = '0.21.4.2'
 
 from erepublik import classes, utils, constants
 from erepublik.citizen import Citizen

erepublik/access_points.py

@@ -12,29 +12,31 @@ __all__ = ['SlowRequests', 'CitizenAPI']
 
 class SlowRequests(Session):
     last_time: datetime.datetime
-    timeout = datetime.timedelta(milliseconds=500)
+    timeout: datetime.timedelta = datetime.timedelta(milliseconds=500)
-    uas = [
+    uas: List[str] = [
         # Chrome
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36',  # noqa
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',  # noqa
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36',  # noqa
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',  # noqa
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',  # noqa
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',
 
         # FireFox
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:76.0) Gecko/20100101 Firefox/76.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:75.0) Gecko/20100101 Firefox/75.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:82.0) Gecko/20100101 Firefox/82.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:81.0) Gecko/20100101 Firefox/81.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:73.0) Gecko/20100101 Firefox/73.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:80.0) Gecko/20100101 Firefox/80.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:76.0) Gecko/20100101 Firefox/76.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:79.0) Gecko/20100101 Firefox/79.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:75.0) Gecko/20100101 Firefox/75.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Firefox/78.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:74.0) Gecko/20100101 Firefox/74.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:83.0) Gecko/20100101 Firefox/83.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:73.0) Gecko/20100101 Firefox/73.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:82.0) Gecko/20100101 Firefox/82.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:81.0) Gecko/20100101 Firefox/81.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:79.0) Gecko/20100101 Firefox/79.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0',
     ]
-    debug = False
+    debug: bool = False
 
     def __init__(self):
         super().__init__()
@@ -113,12 +115,13 @@ class SlowRequests(Session):
 
 class CitizenBaseAPI:
     url: str = "https://www.erepublik.com/en"
-    _req: SlowRequests = None
+    _req: SlowRequests
-    token: str = ""
+    token: str
 
     def __init__(self):
         """ Class for unifying eRepublik known endpoints and their required/optional parameters """
         self._req = SlowRequests()
+        self.token = ""
 
     def post(self, url: str, data=None, json=None, **kwargs) -> Response:
         return self._req.post(url, data, json, **kwargs)
@@ -433,7 +436,7 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
 
 class ErepublikPoliticsAPI(CitizenBaseAPI):
     def _get_candidate_party(self, party_slug: str) -> Response:
-        return self.post(f"{self.url}/candidate/{party_slug}")
+        return self.get(f"{self.url}/candidate/{party_slug}")
 
     def _get_main_party_members(self, party_id: int) -> Response:
         return self.get(f"{self.url}/main/party-members/{party_id}")
@@ -448,6 +451,13 @@ class ErepublikPoliticsAPI(CitizenBaseAPI):
     def _get_presidential_elections(self, country_id: int, timestamp: int) -> Response:
         return self.get(f"{self.url}/main/presidential-elections/{country_id}/{timestamp}")
 
+    def _post_propose_president_candidate(self, party_slug: str, citizen_id: int) -> Response:
+        return self.post(f"{self.url}/propose-president-candidate/{party_slug}",
+                         data=dict(_token=self.token, citizen=citizen_id))
+
+    def _get_auto_propose_president_candidate(self, party_slug: str) -> Response:
+        return self.get(f"{self.url}/auto-propose-president-candidate/{party_slug}")
+
 
 class ErepublikPresidentAPI(CitizenBaseAPI):
     def _post_wars_attack_region(self, war_id: int, region_id: int, region_name: str) -> Response:

erepublik/citizen.py

@@ -393,7 +393,7 @@ class BaseCitizen(access_points.CitizenAPI):
             sleep(seconds)
 
     def to_json(self, indent: bool = False) -> str:
-        return utils.json.dumps(self, cls=classes.MyJSONEncoder, indent=4 if indent else None, sort_keys=True)
+        return utils.json.dumps(self, cls=classes.MyJSONEncoder, indent=4 if indent else None)
 
     def get_countries_with_regions(self) -> Set[constants.Country]:
         r_json = self._post_main_travel_data().json()
@@ -833,23 +833,21 @@ class CitizenCompanies(BaseCitizen):
     def work_as_manager_in_holding(self, holding: classes.Holding) -> Optional[Dict[str, Any]]:
         return self._work_as_manager(holding)
 
-    def _work_as_manager(self, wam_holding: classes.Holding = None) -> Optional[Dict[str, Any]]:
+    def _work_as_manager(self, wam_holding: classes.Holding) -> Optional[Dict[str, Any]]:
         if self.restricted_ip:
             return None
         self.update_companies()
         self.update_inventory()
         data = {"action_type": "production"}
         extra = {}
-        wam_list = []
+        raw_factories = wam_holding.get_wam_companies(raw_factory=True)
-        if wam_holding:
+        fin_factories = wam_holding.get_wam_companies(raw_factory=False)
-            raw_factories = wam_holding.get_wam_companies(raw_factory=True)
-            fin_factories = wam_holding.get_wam_companies(raw_factory=False)
 
-            free_inventory = self.inventory["total"] - self.inventory["used"]
+        free_inventory = self.inventory["total"] - self.inventory["used"]
-            wam_list = raw_factories + fin_factories
+        wam_list = raw_factories + fin_factories
-            wam_list = wam_list[:self.energy.food_fights]
+        wam_list = wam_list[:self.energy.food_fights]
-            while wam_list and free_inventory < self.my_companies.get_needed_inventory_usage(wam_list):
+        while wam_list and free_inventory < self.my_companies.get_needed_inventory_usage(wam_list):
-                wam_list.pop(-1)
+            wam_list.pop(-1)
 
         if wam_list:
             data.update(extra)
@@ -1016,7 +1014,7 @@ class CitizenEconomy(CitizenTravel):
             self.write_log(f"Trying to sell unsupported industry {industry}")
 
         data = {
-            "country_id": self.details.citizenship,
+            "country_id": self.details.citizenship.id,
             "industry": industry,
             "quality": quality,
             "amount": amount,
@@ -1071,7 +1069,7 @@ class CitizenEconomy(CitizenTravel):
         start_dt = self.now
         iterable = [countries, [quality] if quality else range(1, max_quality + 1)]
         for country, q in product(*iterable):
-            r = self._post_economy_marketplace(country, constants.INDUSTRIES[product_name], q).json()
+            r = self._post_economy_marketplace(country.id, constants.INDUSTRIES[product_name], q).json()
             obj = offers[f"q{q}"]
             if not r.get("error", False):
                 for offer in r["offers"]:
@@ -1314,9 +1312,6 @@ class CitizenMilitary(CitizenTravel):
     boosters: Dict[int, Dict[int, int]] = {100: {}, 50: {}}
 
     def update_war_info(self):
-        if not self.details.current_country:
-            self.update_citizen_info()
-
         if self.__last_war_update_data and self.__last_war_update_data.get('last_updated',
                                                                            0) + 30 > self.now.timestamp():
             r_json = self.__last_war_update_data
@@ -1341,7 +1336,10 @@ class CitizenMilitary(CitizenTravel):
                 all_battles = {}
                 for battle_data in r_json.get("battles", {}).values():
                     all_battles[battle_data.get('id')] = classes.Battle(battle_data)
+                old_all_battles = self.all_battles
                 self.all_battles = all_battles
+                for battle in old_all_battles.values():
+                    utils._clear_up_battle_memory(battle)
 
     def get_battle_for_war(self, war_id: int) -> Optional[classes.Battle]:
         self.update_war_info()
@@ -1516,35 +1514,33 @@ class CitizenMilitary(CitizenTravel):
         ret_battles = ret_battles + cs_battles + deployed_battles + other_battles
         return ret_battles
 
-    def get_cheap_tp_divisions(self) -> Optional[classes.BattleDivision]:
+    def get_cheap_tp_divisions(self) -> Dict[str, List[Tuple[int, classes.BattleDivision]]]:
-        air_divs: List[Tuple[classes.BattleDivision, int]] = []
+        air_divs: List[Tuple[int, classes.BattleDivision]] = []
-        ground_divs: List[Tuple[classes.BattleDivision, int]] = []
+        ground_divs: List[Tuple[int, classes.BattleDivision]] = []
         for battle in reversed(self.sorted_battles(True, True)):
             for division in battle.div.values():
-                if not division.terrain:
+                is_start_ok = utils.good_timedelta(division.battle.start, timedelta(minutes=-1)) < self.now
+                if not division.terrain and is_start_ok and not division.div_end:
                     if division.is_air and self.config.air:
-                        medal = self.get_battle_round_data(division)[
+                        division_medals = self.get_battle_round_data(division)
-                            self.details.citizenship == division.battle.defender.id]
+                        medal = division_medals[self.details.citizenship == division.battle.is_defender.country]
-                        if not medal and division.battle.start:
+                        if not medal:
-                            return division
+                            air_divs.append((0, division))
                         else:
-                            air_divs.append((division, medal.get('1').get('raw_value')))
+                            air_divs.append((medal.get('1').get('raw_value'), division))
-                    elif self.config.ground:
+                    elif not division.is_air and self.config.ground:
                         if not division.div == self.division and not self.maverick:
                             continue
                         division_medals = self.get_battle_round_data(division)
-                        medal = division_medals[self.details.citizenship == division.battle.defender.country]
+                        medal = division_medals[self.details.citizenship == division.battle.is_defender.country]
-                        if not medal and division.battle.start:
+                        if not medal:
-                            return division
+                            ground_divs.append((0, division))
                         else:
-                            ground_divs.append((division, medal.get('1').get('raw_value')))
+                            ground_divs.append((medal.get('1').get('raw_value'), division))
 
-        if self.config.air:
+        air_divs.sort(key=lambda z: (z[0], z[1].battle.start))
-            return min(air_divs, key=lambda x: x[1])[0]
+        ground_divs.sort(key=lambda z: (z[0], z[1].battle.start))
-        elif self.config.ground:
+        return {'air': air_divs, 'ground': ground_divs}
-            return min(ground_divs, key=lambda x: x[1])[0]
-        else:
-            return
 
     @property
     def has_battle_contribution(self):
@@ -1611,14 +1607,15 @@ class CitizenMilitary(CitizenTravel):
                     self.travel_to_residence()
                     break
 
-    def fight(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide = None, count: int = None) -> int:
+    def fight(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide = None,
+              count: int = None) -> int:
         """Fight in a battle.
 
         Will auto activate booster and travel if allowed to do it.
         :param battle: Battle battle to fight in
         :type battle: Battle
         :param side: BattleSide or None. Battle side to fight in, If side not == invader id or not in invader deployed
-                                     allies list, then defender's side is chosen
+        allies list, then defender's side is chosen
         :type side: BattleSide
         :param count: How many hits to do, if not specified self.should_fight() is called.
         :type count: int
@@ -1657,7 +1654,10 @@ class CitizenMilitary(CitizenTravel):
                     self.write_log("Hits: {:>4} | Damage: {}".format(total_hits, total_damage))
                     ok_to_fight = False
                     if total_damage:
-                        self.reporter.report_action("FIGHT", dict(battle=battle, side=side, dmg=total_damage,
+                        self.reporter.report_action('FIGHT', dict(battle_id=battle.id, side=side, dmg=total_damage,
+                                                                  air=battle.has_air, hits=total_hits,
+                                                                  round=battle.zone_id))
+                        self.reporter.report_action("FIGHT", dict(battle=str(battle), side=str(side), dmg=total_damage,
                                                                   air=battle.has_air, hits=total_hits))
         return error_count
 
@@ -1765,7 +1765,8 @@ class CitizenMilitary(CitizenTravel):
         if resp.json().get('error'):
             self.write_log(resp.json().get('message'))
             return False
-        self._report_action("MILITARY_DIV_SWITCH", f"Switched to d{division.div} in battle {battle.id}", kwargs=resp.json())
+        self._report_action("MILITARY_DIV_SWITCH", f"Switched to d{division.div} in battle {battle.id}",
+                            kwargs=resp.json())
         return True
 
     def get_ground_hit_dmg_value(self, rang: int = None, strength: float = None, elite: bool = None, ne: bool = False,
@@ -1905,7 +1906,7 @@ class CitizenMilitary(CitizenTravel):
                                                battleZoneId=division.id, type="damage")
         r_json = r.json()
         return (r_json.get(str(battle.invader.id)).get("fighterData"),
-                r_json.get(str(battle.defender.id)).get("fighterData"))
+                r_json.get(str(battle.is_defender.id)).get("fighterData"))
 
     def schedule_attack(self, war_id: int, region_id: int, region_name: str, at_time: datetime):
         if at_time:
@@ -1965,6 +1966,13 @@ class CitizenMilitary(CitizenTravel):
             return member.get('panelContents', {}).get('members', [{}])[0].get('dailyOrdersCompleted')
         return 0
 
+    def get_possibly_empty_medals(self):
+        self.update_war_info()
+        for battle in self.all_battles.values():
+            for division in battle.div.values():
+                if division.wall['dom'] == 50 or division.wall['dom'] > 98:
+                    yield division, division.wall['for'] == battle.invader.country.id
+
 
 class CitizenPolitics(BaseCitizen):
     def get_country_parties(self, country: constants.Country = None) -> dict:
@@ -2337,11 +2345,11 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
                 self.reporter.report_action("NEW_MEDAL", info)
 
     def set_debug(self, debug: bool):
-        self.debug = debug
+        self.debug = bool(debug)
-        self._req.debug = debug
+        self._req.debug = bool(debug)
 
     def set_pin(self, pin: int):
-        self.details.pin = pin
+        self.details.pin = int(pin)
 
     def update_all(self, force_update=False):
         # Do full update max every 5 min
@@ -2514,7 +2522,8 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
                 else:
                     if not start_place == (self.details.current_country, self.details.current_region):
                         self.travel_to_holding(holding)
-                    return self._wam(holding)
+                    self._wam(holding)
+                    return
         elif response.get("message") == "not_enough_health_food":
             self.buy_food()
             self._wam(holding)
@@ -2530,7 +2539,7 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
         :rtype: bool
         """
         if self.restricted_ip:
-            self._report_action("IP_BLACKLISTED", "Fighting is not allowed from restricted IP!")
+            self._report_action("IP_BLACKLISTED", "Work as manager is not allowed from restricted IP!")
             return False
         self.update_citizen_info()
         self.update_companies()
@@ -2547,6 +2556,10 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
                 self.update_companies()
 
             for holding in regions.values():
+                raw_usage = holding.get_wam_raw_usage()
+                if (raw_usage['frm'] + raw_usage['wrm']) * 100 + self.inventory['used'] > self.inventory['total']:
+                    self._report_action('WAM_UNAVAILABLE', 'Not enough storage!')
+                    continue
                 self.travel_to_holding(holding)
                 self._wam(holding)
                 self.update_companies()

erepublik/classes.py

@@ -1,6 +1,7 @@
 import datetime
 import hashlib
 import threading
+import weakref
 from decimal import Decimal
 from typing import Any, Dict, List, NamedTuple, Optional, Tuple, Union
 
@@ -27,9 +28,10 @@ class Holding:
     id: int
     region: int
     companies: List["Company"]
+    _citizen = weakref.ReferenceType
 
     def __init__(self, _id: int, region: int, citizen):
-        self.citizen = citizen
+        self._citizen = weakref.ref(citizen)
         self.id: int = _id
         self.region: int = region
         self.companies: List["Company"] = list()
@@ -93,8 +95,13 @@ class Holding:
     def as_dict(self):
         return dict(name=str(self), id=self.id, region=self.region, companies=self.companies, wam_count=self.wam_count)
 
+    @property
+    def citizen(self):
+        return self._citizen()
+
 
 class Company:
+    _holding: weakref.ReferenceType
     holding: Holding
     id: int
     quality: int
@@ -113,7 +120,7 @@ class Company:
         base_production: Decimal, wam_enabled: bool, can_wam: bool, cannot_wam_reason: str, industry: int,
         already_worked: bool, preset_works: int
     ):
-        self.holding: Holding = holding
+        self._holding = weakref.ref(holding)
         self.id: int = _id
         self.industry: int = industry
         self.quality: int = self._get_real_quality(quality)
@@ -211,6 +218,10 @@ class Company:
         # noinspection PyProtectedMember
         return self.holding.citizen._post_economy_upgrade_company(self.id, level, self.holding.citizen.details.pin)
 
+    @property
+    def holding(self):
+        return self._holding()
+
 
 class MyCompanies:
     work_units: int = 0
@@ -218,13 +229,13 @@ class MyCompanies:
     ff_lockdown: int = 0
 
     holdings: Dict[int, Holding]
-    companies: List[Company]
+    companies: weakref.WeakSet
+    _citizen: weakref.ReferenceType
 
     def __init__(self, citizen):
-        from erepublik import Citizen
+        self._citizen = weakref.ref(citizen)
-        self.citizen: Citizen = citizen
         self.holdings: Dict[int, Holding] = dict()
-        self.companies: List[Company] = list()
+        self.companies: weakref.WeakSet = weakref.WeakSet()
         self.next_ot_time = utils.now()
 
     def prepare_holdings(self, holdings: Dict[str, Dict[str, Any]]):
@@ -233,8 +244,9 @@ class MyCompanies:
         """
         for holding in holdings.values():
             if holding.get('id') not in self.holdings:
-                self.holdings.update(
+                self.holdings.update({
-                    {int(holding.get('id')): Holding(holding['id'], holding['region_id'], self.citizen)})
+                    int(holding.get('id')): Holding(holding['id'], holding['region_id'], self.citizen)
+                })
         if not self.holdings.get(0):
             self.holdings.update({0: Holding(0, 0, self.citizen)})  # unassigned
 
@@ -258,7 +270,7 @@ class MyCompanies:
                 company_dict.get('can_work_as_manager'), company_dict.get('cannot_work_as_manager_reason'),
                 company_dict.get('industry_id'), company_dict.get('already_worked'), company_dict.get('preset_works')
             )
-            self.companies.append(company)
+            self.companies.add(company)
             holding.add_company(company)
 
     def get_employable_factories(self) -> Dict[int, int]:
@@ -282,6 +294,8 @@ class MyCompanies:
 
     def __clear_data(self):
         for holding in self.holdings.values():
+            for company in holding.companies:  # noqa
+                del company
             holding.companies.clear()
         self.companies.clear()
 
@@ -290,6 +304,10 @@ class MyCompanies:
         return dict(name=str(self), work_units=self.work_units, next_ot_time=self.next_ot_time,
                     ff_lockdown=self.ff_lockdown, holdings=self.holdings, company_count=len(self.companies))
 
+    @property
+    def citizen(self):
+        return self._citizen()
+
 
 class Config:
     email = ""
@@ -528,10 +546,13 @@ class Reporter:
                     queue=self.__to_update)
 
     def __init__(self, citizen):
-        self.citizen = citizen
+        self._citizen = weakref.ref(citizen)
         self._req = Session()
         self.url = "https://api.erep.lv"
-        self._req.headers.update({"user-agent": "Bot reporter v2"})
+        self._req.headers.update({"user-agent": "eRepublik Script Reporter v3",
+                                  'erep-version': utils.__version__,
+                                  'erep-user-id': self.citizen_id,
+                                  'erep-user-name': self.citizen.name})
         self.__to_update = []
         self.__registered: bool = False
 
@@ -541,6 +562,10 @@ class Reporter:
         self.register_account()
         self.allowed = True
 
+    @property
+    def citizen(self):
+        return self._citizen()
+
     def __update_key(self):
         self.key = hashlib.md5(bytes(f"{self.name}:{self.email}", encoding="UTF-8")).hexdigest()
 
@@ -548,10 +573,10 @@ class Reporter:
         if self.__to_update:
             for unreported_data in self.__to_update:
                 unreported_data.update(player_id=self.citizen_id, key=self.key)
-                unreported_data = utils.json.load(utils.json.dumps(unreported_data, cls=MyJSONEncoder, sort_keys=True))
+                unreported_data = utils.json.loads(utils.json.dumps(unreported_data, cls=MyJSONEncoder))
                 self._req.post("{}/bot/update".format(self.url), json=unreported_data)
             self.__to_update.clear()
-        data = utils.json.loads(utils.json.dumps(data, cls=MyJSONEncoder, sort_keys=True))
+        data = utils.json.loads(utils.json.dumps(data, cls=MyJSONEncoder))
         r = self._req.post("{}/bot/update".format(self.url), json=data)
         return r
 
@@ -604,13 +629,13 @@ class Reporter:
         except:  # noqa
             return []
 
-    def fetch_tasks(self) -> Optional[Tuple[str, Tuple[Any]]]:
+    def fetch_tasks(self) -> List[Union[str, Tuple[Any]]]:
         try:
             task_response = self._req.get(f'{self.url}/api/v1/command',
                                           params=dict(citizen=self.citizen_id, key=self.key))
             return task_response.json().get('task_collection')
         except:  # noqa
-            return
+            return []
 
 
 class MyJSONEncoder(utils.json.JSONEncoder):
@@ -645,28 +670,29 @@ class BattleSide:
     deployed: List[constants.Country]
     allies: List[constants.Country]
     battle: "Battle"
+    _battle: weakref.ReferenceType
     country: constants.Country
-    defender: bool
+    is_defender: bool
 
     def __init__(self, battle: "Battle", country: constants.Country, points: int, allies: List[constants.Country],
                  deployed: List[constants.Country], defender: bool):
-        self.battle = battle
+        self._battle = weakref.ref(battle)
         self.country = country
         self.points = points
         self.allies = allies
         self.deployed = deployed
-        self.defender = defender
+        self.is_defender = defender
 
     @property
     def id(self) -> int:
         return self.country.id
 
     def __repr__(self):
-        side_text = "Defender" if self.defender else "Invader "
+        side_text = "Defender" if self.is_defender else "Invader "
         return f"<BattleSide: {side_text} {self.country.name}|{self.points:02d}p>"
 
     def __str__(self):
-        side_text = "Defender" if self.defender else "Invader "
+        side_text = "Defender" if self.is_defender else "Invader "
         return f"{side_text} {self.country.name} - {self.points:02d} points"
 
     def __format__(self, format_spec):
@@ -674,8 +700,12 @@ class BattleSide:
 
     @property
     def as_dict(self):
-        return dict(points=self.points, country=self.country, defender=self.defender, allies=self.allies,
+        return dict(points=self.points, country=self.country, is_defender=self.is_defender, allies=self.allies,
-                    deployed=self.deployed, battle=repr(self.battle))
+                    deployed=self.deployed)
+
+    @property
+    def battle(self):
+        return self._battle()
 
 
 class BattleDivision:
@@ -689,11 +719,12 @@ class BattleDivision:
     terrain: int
     div: int
     battle: "Battle"
+    _battle: weakref.ReferenceType
 
     @property
     def as_dict(self):
         return dict(id=self.id, division=self.div, terrain=(self.terrain, self.terrain_display), wall=self.wall,
-                    epic=self.epic, battle=str(self.battle), end=self.div_end)
+                    epic=self.epic, end=self.div_end)
 
     @property
     def is_air(self):
@@ -715,7 +746,7 @@ class BattleDivision:
         :type wall_for: int
         :type wall_dom: float
         """
-        self.battle = battle
+        self._battle = weakref.ref(battle)
         self.id = div_id
         self.end = end
         self.epic = epic
@@ -738,6 +769,10 @@ class BattleDivision:
     def __repr__(self):
         return f"<BattleDivision #{self.id} (battle #{self.battle.id})>"
 
+    @property
+    def battle(self):
+        return self._battle()
+
 
 class Battle:
     id: int
@@ -756,7 +791,7 @@ class Battle:
     def as_dict(self):
         return dict(id=self.id, war_id=self.war_id, divisions=self.div, zone=self.zone_id, rw=self.is_rw,
                     dict_lib=self.is_dict_lib, start=self.start, sides={'inv': self.invader, 'def': self.defender},
-                    region=[self.region_id, self.region_name])
+                    region=[self.region_id, self.region_name], link=self.link)
 
     @property
     def has_air(self) -> bool:
@@ -765,6 +800,10 @@ class Battle:
                 return True
         return not bool(self.zone_id % 4)
 
+    @property
+    def has_started(self) -> bool:
+        return self.start <= utils.now()
+
     @property
     def has_ground(self) -> bool:
         for div in self.div.values():
@@ -888,7 +927,7 @@ class TelegramBot:
     def as_dict(self):
         return {'chat_id': self.chat_id, 'api_url': self.api_url, 'player': self.player_name,
                 'last_time': self._last_time, 'next_time': self._next_time, 'queue': self.__queue,
-                'initialized': self.__initialized, 'has_threads': bool(len(self._threads))}
+                'initialized': self.__initialized, 'has_threads': not self._threads}
 
     def do_init(self, chat_id: int, token: str, player_name: str = ""):
         self.chat_id = chat_id

erepublik/constants.py

@@ -49,16 +49,16 @@ class Country:
 
 
 class Industries:
-    __by_name = {'food': 1, 'weapons': 2, 'house': 4, 'aircraft': 23,
+    __by_name = {'food': 1, 'weapon': 2, 'house': 4, 'aircraft': 23,
-                 'foodraw': 7, 'weaponraw': 12, 'weaponsraw': 12, 'houseraw': 18, 'aircraftraw': 24,
+                 'foodraw': 7, 'weaponraw': 12, 'houseraw': 18, 'aircraftraw': 24,
                  'frm': 7, 'wrm': 12, 'hrm': 18, 'arm': 24,
                  'frm q1': 7, 'frm q2': 8, 'frm q3': 9, 'frm q4': 10, 'frm q5': 11,
                  'wrm q1': 12, 'wrm q2': 13, 'wrm q3': 14, 'wrm q4': 15, 'wrm q5': 16,
                  'hrm q1': 18, 'hrm q2': 19, 'hrm q3': 20, 'hrm q4': 21, 'hrm q5': 22,
                  'arm q1': 24, 'arm q2': 25, 'arm q3': 26, 'arm q4': 27, 'arm q5': 28}
-    __by_id = {1: "Food", 2: "Weapons", 4: "House", 23: "Aircraft",
+    __by_id = {1: "Food", 2: "Weapon", 4: "House", 23: "Aircraft",
                7: "foodRaw", 8: "FRM q2", 9: "FRM q3", 10: "FRM q4", 11: "FRM q5",
-               12: "weaponsRaw", 13: "WRM q2", 14: "WRM q3", 15: "WRM q4", 16: "WRM q5",
+               12: "weaponRaw", 13: "WRM q2", 14: "WRM q3", 15: "WRM q4", 16: "WRM q5",
                18: "houseRaw", 19: "HRM q2", 20: "HRM q3", 21: "HRM q4", 22: "HRM q5",
                24: "aircraftRaw", 25: "ARM q2", 26: "ARM q3", 27: "ARM q4", 28: "ARM q5"}
 

erepublik/utils.py

@@ -1,4 +1,3 @@
-import copy
 import datetime
 import inspect
 import os
@@ -10,7 +9,7 @@ import traceback
 import unicodedata
 from decimal import Decimal
 from pathlib import Path
-from typing import Any, List, Mapping, Optional, Union, Dict
+from typing import Any, List, Optional, Union, Dict
 
 import requests
 
@@ -43,12 +42,11 @@ def localize_timestamp(timestamp: int) -> datetime.datetime:
 
 
 def localize_dt(dt: Union[datetime.date, datetime.datetime]) -> datetime.datetime:
-    try:
+    if isinstance(dt, datetime.datetime):
-        try:
+        return constants.erep_tz.localize(dt)
-            return constants.erep_tz.localize(dt)
+    elif isinstance(dt, datetime.date):
-        except AttributeError:
+        return constants.erep_tz.localize(datetime.datetime.combine(dt, datetime.time(0, 0, 0)))
-            return constants.erep_tz.localize(datetime.datetime.combine(dt, datetime.time(0, 0, 0)))
+    else:
-    except ValueError:
         return dt.astimezone(constants.erep_tz)
 
 
@@ -117,10 +115,12 @@ def _write_log(msg, timestamp: bool = True, should_print: bool = False):
 
 
 def write_interactive_log(*args, **kwargs):
+    kwargs.pop("should_print", None)
     _write_log(should_print=True, *args, **kwargs)
 
 
 def write_silent_log(*args, **kwargs):
+    kwargs.pop("should_print", None)
     _write_log(should_print=False, *args, **kwargs)
 
 
@@ -230,7 +230,7 @@ def send_email(name: str, content: List[Any], player=None, local_vars: Dict[str,
             local_vars['citizen'] = repr(local_vars['citizen'])
 
         from erepublik.classes import MyJSONEncoder
-        files.append(('file', ("local_vars.json", json.dumps(local_vars, cls=MyJSONEncoder, sort_keys=True),
+        files.append(('file', ("local_vars.json", json.dumps(local_vars, cls=MyJSONEncoder),
                                "application/json")))
     if isinstance(player, Citizen):
         files.append(('file', ("instance.json", player.to_json(indent=True), "application/json")))
@@ -278,16 +278,17 @@ def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commi
     elif interactive is not None:
         write_silent_log(log_info)
     trace = inspect.trace()
+    local_vars = None
     if trace:
-        trace = trace[-1][0].f_locals
+        trace_local_vars = trace[-1][0].f_locals
-        if trace.get('__name__') == '__main__':
+        if trace_local_vars.get('__name__') == '__main__':
-            trace = {'commit_id': trace.get('COMMIT_ID'),
+            local_vars = {'commit_id': trace_local_vars.get('COMMIT_ID'),
-                     'interactive': trace.get('INTERACTIVE'),
+                          'interactive': trace_local_vars.get('INTERACTIVE'),
-                     'version': trace.get('__version__'),
+                          'version': trace_local_vars.get('__version__'),
-                     'config': trace.get('CONFIG')}
+                          'config': trace_local_vars.get('CONFIG')}
     else:
-        trace = dict()
+        local_vars = dict()
-    send_email(name, content, citizen, local_vars=trace)
+    send_email(name, content, citizen, local_vars=local_vars)
 
 
 def process_warning(log_info: str, name: str, exc_info: tuple, citizen=None, commit_id: str = None):
@@ -307,10 +308,10 @@ def process_warning(log_info: str, name: str, exc_info: tuple, citizen=None, com
 
     trace = inspect.trace()
     if trace:
-        trace = trace[-1][0].f_locals
+        local_vars = trace[-1][0].f_locals
     else:
-        trace = dict()
+        local_vars = dict()
-    send_email(name, content, citizen, local_vars=trace)
+    send_email(name, content, citizen, local_vars=local_vars)
 
 
 def slugify(value, allow_unicode=False) -> str:
@@ -368,3 +369,9 @@ def get_air_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_pat
     rang = r['military']['militaryData']['aircraft']['rankNumber']
     elite = r['citizenAttributes']['level'] > 100
     return calculate_hit(0, rang, true_patriot, elite, natural_enemy, booster, weapon_power)
+
+
+def _clear_up_battle_memory(battle):
+    del battle.invader._battle, battle.defender._battle
+    for div_id, division in battle.div.items():
+        del division._battle

requirements_dev.txt

@@ -1,17 +1,18 @@
 bump2version==1.0.0
-coverage==5.2
+coverage==5.3
 edx-sphinx-theme==1.5.0
 flake8==3.8.3
-ipython==7.16.1
+ipython==7.18.1
-isort==5.0.9
+isort==5.5.3
-pip==20.1.1
+pip==20.2.3
-PyInstaller==3.6
+PyInstaller==4.0
 pytz==2020.1
-pytest==5.4.3
+pytest==6.0.2
-responses==0.10.15
+responses==0.12.0
-setuptools==49.2.0
+setuptools==50.3.0
-Sphinx==3.1.2
+Sphinx==3.2.1
-tox==3.16.1
+requests==2.24.0
+tox==3.20.0
 twine==3.2.0
 watchdog==0.10.3
-wheel==0.34.2
+wheel==0.35.1

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.21.1
+current_version = 0.21.4.2
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)\.?(?P<dev>\d+)?
@@ -33,7 +33,6 @@ ignore_missing_imports = False
 warn_unused_ignores = True
 warn_redundant_casts = True
 warn_unused_configs = True
-plugins = mypy_django_plugin.main
 
 [isort]
 multi_line_output = 2

setup.py

@@ -43,6 +43,6 @@ setup(
     test_suite='tests',
     tests_require=test_requirements,
     url='https://github.com/eeriks/erepublik/',
-    version='0.21.1',
+    version='0.21.4.2',
     zip_safe=False,
 )

tests/test_erepublik_script.py

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 """Tests for `erepublik` package."""
+from typing import Callable
 
 from erepublik import Citizen
 
@@ -65,6 +66,7 @@ class TestErepublik(unittest.TestCase):
         self.assertEqual(self.citizen.next_reachable_energy, 0)
 
     def test_should_fight(self):
+        is_wc_close: Callable[[], bool] = lambda: self.citizen.max_time_till_full_ff > self.citizen.time_till_week_change
         self.citizen.config.fight = False
         self.assertEqual(self.citizen.should_fight(), (0, "Fighting not allowed!", False))
 
@@ -73,62 +75,63 @@ class TestErepublik(unittest.TestCase):
         # Level up
         self.citizen.energy.limit = 3000
         self.citizen.details.xp = 24705
-        self.assertEqual(self.citizen.should_fight(), (0, 'Level up', False))
+        if not is_wc_close:
+            self.assertEqual(self.citizen.should_fight(), (0, 'Level up', False))
 
-        self.citizen.energy.recovered = 3000
+            self.citizen.energy.recovered = 3000
-        self.citizen.energy.recoverable = 2950
+            self.citizen.energy.recoverable = 2950
-        self.citizen.energy.interval = 30
+            self.citizen.energy.interval = 30
-        self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
+            self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
-        self.citizen.my_companies.ff_lockdown = 160
+            self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
+            self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.my_companies.ff_lockdown = 0
 
-        # Level up reachable
+            # Level up reachable
-        self.citizen.details.xp = 24400
+            self.citizen.details.xp = 24400
-        self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
+            self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
-        self.citizen.my_companies.ff_lockdown = 160
+            self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
+            self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.my_companies.ff_lockdown = 0
 
-        self.citizen.details.xp = 21000
+            self.citizen.details.xp = 21000
-        self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
+            self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
-        self.citizen.my_companies.ff_lockdown = 160
+            self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
+            self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.my_companies.ff_lockdown = 0
-        self.citizen.details.pp = 80
+            self.citizen.details.pp = 80
 
-        # All-in (type = all-in and full ff)
+            # All-in (type = all-in and full ff)
-        self.citizen.config.all_in = True
+            self.citizen.config.all_in = True
-        self.assertEqual(self.citizen.should_fight(), (595, 'Fighting all-in. Doing 595 hits', False))
+            self.assertEqual(self.citizen.should_fight(), (595, 'Fighting all-in. Doing 595 hits', False))
-        self.citizen.my_companies.ff_lockdown = 160
+            self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (
+            self.assertEqual(self.citizen.should_fight(), (
-            435, 'Fight count modified (old count: 595 | FF: 595 | WAM ff_lockdown: 160 | New count: 435)', False
+                435, 'Fight count modified (old count: 595 | FF: 595 | WAM ff_lockdown: 160 | New count: 435)', False
-        ))
+            ))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.my_companies.ff_lockdown = 0
 
-        self.citizen.config.air = True
+            self.citizen.config.air = True
-        self.citizen.energy.recoverable = 1000
+            self.citizen.energy.recoverable = 1000
-        self.assertEqual(self.citizen.should_fight(), (400, 'Fighting all-in in AIR. Doing 400 hits', False))
+            self.assertEqual(self.citizen.should_fight(), (400, 'Fighting all-in in AIR. Doing 400 hits', False))
-        self.citizen.my_companies.ff_lockdown = 160
+            self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (
+            self.assertEqual(self.citizen.should_fight(), (
-            240, 'Fight count modified (old count: 400 | FF: 400 | WAM ff_lockdown: 160 | New count: 240)', False
+                240, 'Fight count modified (old count: 400 | FF: 400 | WAM ff_lockdown: 160 | New count: 240)', False
-        ))
+            ))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.my_companies.ff_lockdown = 0
-        self.citizen.config.all_in = False
+            self.citizen.config.all_in = False
 
-        self.citizen.config.next_energy = True
+            self.citizen.config.next_energy = True
-        self.citizen.energy.limit = 5000
+            self.citizen.energy.limit = 5000
-        self.citizen.details.next_pp = [100, 150, 250, 400, 500]
+            self.citizen.details.next_pp = [100, 150, 250, 400, 500]
-        self.assertEqual(self.citizen.should_fight(), (320, 'Fighting for +1 energy. Doing 320 hits', False))
+            self.assertEqual(self.citizen.should_fight(), (320, 'Fighting for +1 energy. Doing 320 hits', False))
-        self.citizen.my_companies.ff_lockdown = 160
+            self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (
+            self.assertEqual(self.citizen.should_fight(), (
-            160, 'Fight count modified (old count: 320 | FF: 400 | WAM ff_lockdown: 160 | New count: 160)', False
+                160, 'Fight count modified (old count: 320 | FF: 400 | WAM ff_lockdown: 160 | New count: 160)', False
-        ))
+            ))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.my_companies.ff_lockdown = 0
-        self.citizen.energy.limit = 3000
+            self.citizen.energy.limit = 3000
-        self.citizen.details.next_pp = [19250, 20000]
+            self.citizen.details.next_pp = [19250, 20000]
-        self.citizen.config.next_energy = False
+            self.citizen.config.next_energy = False
 
-        # 1h worth of energy
+            # 1h worth of energy
-        self.citizen.energy.recoverable = 2910
+            self.citizen.energy.recoverable = 2910
-        self.assertEqual(self.citizen.should_fight(), (30, 'Fighting for 1h energy. Doing 30 hits', True))
+            self.assertEqual(self.citizen.should_fight(), (30, 'Fighting for 1h energy. Doing 30 hits', True))