Bump version: 0.23.4.10 → 0.23.4.11

Explicitly updated all Citizen*.as_dict properties

docs/erepublik.rst

@@ -36,6 +36,14 @@ erepublik.constants module
    :undoc-members:
    :show-inheritance:
 
+erepublik.types module
+----------------------
+
+.. automodule:: erepublik.types
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
 erepublik.utils module
 ----------------------
 

erepublik/__init__.py

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

erepublik/access_points.py

@@ -120,6 +120,10 @@ class CitizenBaseAPI:
         self._req = SlowRequests()
         self.token = ""
 
+    @property
+    def as_dict(self):
+        return dict(url=self.url, request=self._req.as_dict, token=self.token)
+
     def post(self, url: str, data=None, json=None, **kwargs) -> Response:
         return self._req.post(url, data, json, **kwargs)
 
@@ -305,11 +309,11 @@ class ErepublikEconomyAPI(CitizenBaseAPI):
         return self.post(f"{self.url}/main/buyGoldItems", data=data)
 
     def _post_economy_activate_booster(self, quality: int, duration: int, kind: str) -> Response:
-        data = dict(type=kind, quality=quality, duration=duration, fromInventory=True)
+        data = dict(type=kind, quality=quality, duration=duration, fromInventory=True, _token=self.token)
         return self.post(f"{self.url}/economy/activateBooster", data=data)
 
     def _post_economy_activate_house(self, quality: int) -> Response:
-        data = {"action": "activate", "quality": quality, "type": "house", "_token": self.token}
+        data = dict(action="activate", quality=quality, type="house", _token=self.token)
         return self.post(f"{self.url}/economy/activateHouse", data=data)
 
     def _post_economy_donate_items_action(self, citizen_id: int, amount: int, industry: int,

erepublik/citizen.py

@@ -38,9 +38,9 @@ class BaseCitizen(access_points.CitizenAPI):
     energy: classes.Energy = None
     details: classes.Details = None
     politics: classes.Politics = None
+    my_companies: classes.MyCompanies = None
     reporter: classes.Reporter = None
     stop_threads: Event = None
-    concurrency_available: Event = None
     telegram: classes.TelegramReporter = None
 
     r: Response = None
@@ -57,8 +57,6 @@ class BaseCitizen(access_points.CitizenAPI):
         self.my_companies = classes.MyCompanies(self)
         self.reporter = classes.Reporter(self)
         self.stop_threads = Event()
-        self.concurrency_available = Event()
-        self.concurrency_available.set()
         self.telegram = classes.TelegramReporter(stop_event=self.stop_threads)
 
         self.config.email = email
@@ -238,10 +236,7 @@ class BaseCitizen(access_points.CitizenAPI):
 
     def update_inventory(self):
         """
-        Updates class properties and returns structured inventory.
-        Return structure: {status: {used: int, total: int}, items: {active/final/raw: {item_token:{quality: data}}}
-        If item kind is damageBoosters or aircraftDamageBoosters then kind is renamed to kind+quality and duration is
-        used as quality.
+        Updates citizen inventory
         """
         self._update_inventory_data(self._get_economy_inventory_items().json())
 
@@ -291,8 +286,9 @@ class BaseCitizen(access_points.CitizenAPI):
                 if item_data.get('attributes').get('expirationInfo'):
                     expire_info = item_data.get('attributes').get('expirationInfo')
                     expiration_info = [_expire_value_to_python(v) for v in expire_info['value']]
-                icon = item_data['icon'] if item_data[
-                    'icon'] else "//www.erepublik.net/images/modules/manager/tab_storage.png"
+                if not item_data.get('icon') and item_data.get('isPackBooster'):
+                    item_data['icon'] = f"//www.erepublik.com/images/icons/boosters/52px/{item_data.get('type')}.png"
+                icon = item_data['icon'] if item_data['icon'] else "//www.erepublik.net/images/modules/manager/tab_storage.png"
                 inv_item: types.InvFinalItem = dict(
                     name=item_data.get("name"), time_left=item_data['active']['time_left'], icon=icon,
                     kind=kind, expiration=expiration_info, quality=item_data.get("quality", 0)
@@ -312,7 +308,7 @@ class BaseCitizen(access_points.CitizenAPI):
 
                 if item_data.get('type'):
                     #  in ['damageBoosters', "aircraftDamageBoosters", 'prestigePointsBoosters']
-                    if item_data.get('type').endswith('Boosters'):
+                    if item_data.get('isBooster'):
                         is_booster = True
                         kind = item_data['type']
 
@@ -343,6 +339,9 @@ class BaseCitizen(access_points.CitizenAPI):
                             elif q == 15:
                                 self.eb_small += amount
                                 item_data.update(token='energy_bar')
+                            elif q == 16:
+                                self.eb_small += amount
+                                item_data.update(token='energy_bar')
                     kind = re.sub(r'_q\d\d*', "", item_data.get('token'))
 
                 if item_data.get('token', "") == "house_q100":
@@ -469,7 +468,7 @@ class BaseCitizen(access_points.CitizenAPI):
         self._req.debug = bool(debug)
 
     def to_json(self, indent: bool = False) -> str:
-        return utils.json.dumps(self, cls=classes.MyJSONEncoder, indent=4 if indent else None)
+        return utils.json.dumps(self, cls=classes.MyJSONEncoder, indent=4 if indent else None, sort_keys=True)
 
     def get_countries_with_regions(self) -> Set[constants.Country]:
         r_json = self._post_main_travel_data().json()
@@ -524,18 +523,29 @@ class BaseCitizen(access_points.CitizenAPI):
 
     @property
     def as_dict(self):
-        ret = self.__dict__.copy()
-        ret.pop('stop_threads', None)
-        ret.pop('_CitizenMilitary__last_war_update_data', None)
-        ret.update(_properties=dict(
-            now=self.now, should_do_levelup=self.should_do_levelup, is_levelup_reachable=self.is_levelup_reachable,
-            max_time_till_full_ff=self.max_time_till_full_ff, is_levelup_close=self.is_levelup_close,
-            time_till_full_ff=self.time_till_full_ff, time_till_week_change=self.time_till_week_change,
-            next_wc_start=self.next_wc_start, next_reachable_energy=self.next_reachable_energy,
-            health_info=self.health_info))
-
+        ret = super().as_dict
+        ret.update(
+            name=self.name, __str__=self.__str__(),
+            ebs=dict(normal=self.eb_normal, double=self.eb_double, small=self.eb_small),
+            promos=self.promos, inventory=self._inventory.as_dict, ot_points=self.ot_points, food=self.food,
+            division=self.division, maveric=self.maverick, eday=self.eday, wheel_of_fortune=self.wheel_of_fortune,
+            debug=self.debug,
+            logged_in=self.logged_in, restricted_ip=self.restricted_ip, _properties=dict(
+                now=self.now, should_do_levelup=self.should_do_levelup, is_levelup_reachable=self.is_levelup_reachable,
+                max_time_till_full_ff=self.max_time_till_full_ff, is_levelup_close=self.is_levelup_close,
+                time_till_full_ff=self.time_till_full_ff, time_till_week_change=self.time_till_week_change,
+                next_wc_start=self.next_wc_start, next_reachable_energy=self.next_reachable_energy,
+                health_info=self.health_info),
+            _last_full_update=self._last_full_update, _last_inventory_update=self._last_inventory_update,
+            config=self.config.as_dict, energy=self.energy.as_dict, details=self.details.as_dict,
+            politics=self.politics.as_dict, my_companies=self.my_companies.as_dict, reporter=self.reporter.as_dict,
+            telegram=self.telegram.as_dict, stop_threads=self.stop_threads.is_set(), response=self.r,
+        )
         return ret
 
+    def set_locks(self):
+        self.stop_threads.set()
+
     @property
     def health_info(self):
         ret = f"{self.energy.recovered}/{self.energy.limit} + {self.energy.recoverable}, " \
@@ -692,6 +702,10 @@ class BaseCitizen(access_points.CitizenAPI):
                 self.eb_double -= amount
             elif q == "12":
                 self.eb_small -= amount
+            elif q == "15":
+                self.eb_small -= amount
+            elif q == "16":
+                self.eb_small -= amount
         next_recovery = r_json.get("food_remaining_reset").split(":")
         self.energy.set_reference_time(
             utils.good_timedelta(self.now, timedelta(seconds=int(next_recovery[1]) * 60 + int(next_recovery[2])))
@@ -975,7 +989,6 @@ class CitizenCompanies(BaseCitizen):
     def work_as_manager_in_holding(self, holding: classes.Holding) -> Optional[Dict[str, Any]]:
         return self._work_as_manager(holding)
 
-    @utils.wait_for_lock
     def _work_as_manager(self, wam_holding: classes.Holding) -> Optional[Dict[str, Any]]:
         if self.restricted_ip:
             return None
@@ -1045,7 +1058,7 @@ class CitizenCompanies(BaseCitizen):
 
 
 class CitizenEconomy(CitizenTravel):
-    def update_money(self, page: int = 0, currency: int = 62) -> Dict[str, Any]:
+    def update_money(self, page: int = 0, currency: int = 62):
         """
         Gets monetary market offers to get exact amount of CC and Gold available
         """
@@ -1055,7 +1068,6 @@ class CitizenEconomy(CitizenTravel):
         resp_data = resp.json()
         self.details.cc = float(resp_data.get("ecash").get("value"))
         self.details.gold = float(resp_data.get("gold").get("value"))
-        return resp_data
 
     def check_house_durability(self) -> Dict[int, datetime]:
         ret = {}
@@ -1077,7 +1089,7 @@ class CitizenEconomy(CitizenTravel):
             local_cheapest = sorted(offers, key=lambda o: o.price)[0]
 
             global_cheapest = self.get_market_offers("House", q)[f"q{q}"]
-            if global_cheapest.price + 200 < local_cheapest.price:
+            if global_cheapest.price + 2000 < local_cheapest.price:
                 if global_cheapest.price + 2000 < self.details.cc:
                     if self.travel_to_country(global_cheapest.country):
                         buy = self.buy_market_offer(global_cheapest, 1)
@@ -1207,7 +1219,7 @@ class CitizenEconomy(CitizenTravel):
         items = (self.inventory.final if final_kind else self.inventory.raw).get(constants.INDUSTRIES[industry],
                                                                                  {_inv_qlt: {'amount': 0}})
         if items[_inv_qlt]['amount'] < amount:
-            self.get_inventory(True)
+            self.update_inventory()
             items = (self.inventory.final if final_kind else self.inventory.raw).get(constants.INDUSTRIES[industry],
                                                                                      {_inv_qlt: {'amount': 0}})
             if items[_inv_qlt]['amount'] < amount:
@@ -1239,7 +1251,6 @@ class CitizenEconomy(CitizenTravel):
             self._report_action("BOUGHT_PRODUCTS", json_ret.get('message'), kwargs=json_ret)
         return json_ret
 
-    @utils.wait_for_lock
     def buy_market_offer(self, offer: OfferItem, amount: int = None) -> Optional[Dict[str, Any]]:
         if amount is None or amount > offer.amount:
             amount = offer.amount
@@ -1366,7 +1377,7 @@ class CitizenEconomy(CitizenTravel):
         self.update_money()
         cur = "g" if currency == 62 else "cc"
         if success:
-            self._report_action("DONATE_MONEY", f"Successfully donated {amount}{cur} to citizen with id {citizen_id}!")
+            self.report_money_donation(citizen_id, amount, currency == 1)
         else:
             self._report_action("DONATE_MONEY", f"Unable to donate {amount}{cur}!")
         return success
@@ -1450,6 +1461,16 @@ class CitizenEconomy(CitizenTravel):
                                                    f" treasury", kwargs=r.json())
             return False
 
+    def report_money_donation(self, citizen_id: int, amount: float, is_currency: bool = True):
+        self.reporter.report_money_donation(citizen_id, amount, is_currency)
+        if self.config.telegram:
+            self.telegram.report_money_donation(citizen_id, amount, is_currency)
+
+    def report_item_donation(self, citizen_id: int, amount: float, quality: int, industry: str):
+        self.reporter.report_item_donation(citizen_id, amount, quality, industry)
+        if self.config.telegram:
+            self.telegram.report_item_donation(citizen_id, amount, f"{industry} q{quality}")
+
 
 class CitizenLeaderBoard(BaseCitizen):
     def get_aircraft_damage_rankings(self, country: int, weeks: int = 0, mu: int = 0) -> Dict[str, any]:
@@ -1530,11 +1551,15 @@ class CitizenMedia(BaseCitizen):
 
 class CitizenMilitary(CitizenTravel):
     all_battles: Dict[int, classes.Battle] = None
-    countries: Dict[int, Dict[str, Union[str, List[int]]]] = None
     __last_war_update_data = None
 
     active_fs: bool = False
-    boosters: Dict[int, Dict[int, int]] = {100: {}, 50: {}}
+
+    @property
+    def as_dict(self):
+        d = super().as_dict
+        d.update(active_fs=self.active_fs, all_battles=self.all_battles)
+        return d
 
     def update_war_info(self):
         if self.__last_war_update_data and self.__last_war_update_data.get('last_updated',
@@ -1545,17 +1570,6 @@ class CitizenMilitary(CitizenTravel):
         if r_json.get("countries"):
             if self.all_battles is None:
                 self.all_battles = {}
-            if self.countries is None:
-                self.countries = {}
-            countries = {}
-            for c_id, c_data in r_json.get("countries").items():
-                if int(c_id) not in countries:
-                    countries.update({
-                        int(c_id): {"name": c_data.get("name"), "allies": c_data.get("allies")}
-                    })
-                else:
-                    countries[int(c_id)].update(allies=c_data.get("allies"))
-            self.countries = countries
             self.__last_war_update_data = r_json
             if r_json.get("battles"):
                 all_battles = {}
@@ -1775,7 +1789,8 @@ class CitizenMilitary(CitizenTravel):
             yield battle, battle_zone, side
 
     def find_battle_and_fight(self):
-        if self.should_fight()[0]:
+        count = self.should_fight()[0]
+        if count:
             self.write_log("Checking for battles to fight in...")
             for battle, division, side in self.find_battle_to_fight():
 
@@ -1802,25 +1817,26 @@ class CitizenMilitary(CitizenTravel):
 
                 if self.change_division(battle, division):
                     self.set_default_weapon(battle, division)
-                    self.fight(battle, division, side)
+                    self.fight(battle, division, side, count)
                     self.travel_to_residence()
                     break
 
-    @utils.wait_for_lock
     def fight(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide = None,
-              count: int = None) -> Optional[int]:
+              count: int = None, use_ebs: bool = False) -> Optional[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 division: Division number to fight in available choices
+        :type division: BattleDivision
         :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
         :type side: BattleSide
         :param count: How many hits to do, if not specified self.should_fight() is called.
         :type count: int
-        :param division: Division number to fight in available choices
-        :type division: BattleDivision
+        :param use_ebs: Should use energy bars if count > 0 and not enough food_fights
+        :type use_ebs: bool
         :return: None if no errors while fighting, otherwise error count.
         :rtype: int
         """
@@ -1850,15 +1866,13 @@ class CitizenMilitary(CitizenTravel):
                 error_count += error
             else:
                 self._eat('blue')
+                if count > 0 and self.energy.recovered < 50 and use_ebs:
+                    self._eat('orange')
                 if self.energy.recovered < 50 or error_count >= 10 or count <= 0:
                     self.write_log(f"Hits: {total_hits:>4} | Damage: {total_damage}")
                     ok_to_fight = False
                     if total_damage:
-                        self.reporter.report_fighting(battle, not side.is_defender, division, total_damage, total_hits)
-                        # 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,
-                        #                                           extra=dict(battle=battle, side=side)))
+                        self.report_fighting(battle, not side.is_defender, division, total_damage, total_hits)
         return error_count
 
     def _shoot(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide):
@@ -1923,7 +1937,6 @@ class CitizenMilitary(CitizenTravel):
 
         return hits, err, damage
 
-    @utils.wait_for_lock
     def deploy_bomb(self, battle: classes.Battle, division: classes.BattleDivision, bomb_id: int, inv_side: bool,
                     count: int = 1) -> Optional[int]:
         """Deploy bombs in a battle for given side.
@@ -2020,8 +2033,8 @@ class CitizenMilitary(CitizenTravel):
 
         return utils.calculate_hit(0, rang, True, elite, ne, 0, 20 if weapon else 0)
 
-    def activate_damage_booster(self, ground: bool = True):
-        kind = 'damageBoosters' if ground else 'aircraftDamageBoosters'
+    def activate_damage_booster(self, ground: bool = True) -> int:
+        kind = 'damage' if ground else 'aircraftDamage'
         if self.config.boosters and not self.get_active_damage_booster(ground):
             booster: Optional[types.InvFinalItem] = None
             for quality, data in sorted(self.inventory.boosters.get(kind, {}).items(), key=lambda x: x[0]):
@@ -2032,12 +2045,14 @@ class CitizenMilitary(CitizenTravel):
                         break
                 break
             if booster:
+                kind = 'damage' if ground else 'air_damage'
                 self._report_action("MILITARY_BOOSTER", f"Activated {booster['name']}")
-                self._post_economy_activate_booster(booster['quality'], booster['durability'],
-                                                    'damage' if ground else 'air_damage')
+                resp = self._post_economy_activate_booster(booster['quality'], booster['durability'], kind).json()
+                self._update_inventory_data(resp)
+        return self.get_active_damage_booster(ground)
 
     def get_active_damage_booster(self, ground: bool = True) -> int:
-        kind = 'damageBoosters' if ground else 'aircraftDamageBoosters'
+        kind = 'damage' if ground else 'aircraftDamage'
         boosters = self.inventory.active.get(kind, {})
         quality = 0
         for q, boost in boosters.items():
@@ -2051,13 +2066,16 @@ class CitizenMilitary(CitizenTravel):
     def get_active_air_damage_booster(self) -> int:
         return self.get_active_damage_booster(False)
 
-    def activate_battle_effect(self, battle_id: int, kind: str) -> Response:
+    def activate_battle_effect(self, battle_id: int, kind: str) -> bool:
         self._report_action('MILITARY_BOOSTER', f'Activated {kind} booster')
-        return self._post_main_activate_battle_effect(battle_id, kind, self.details.citizen_id)
+        resp = self._post_main_activate_battle_effect(battle_id, kind, self.details.citizen_id).json()
+        return not resp.get('error')
 
-    def activate_pp_booster(self, pp_item: types.InvFinalItem) -> Response:
+    def activate_pp_booster(self, pp_item: types.InvFinalItem) -> bool:
         self._report_action('MILITARY_BOOSTER', f'Activated {pp_item["name"]}')
-        return self._post_economy_activate_booster(pp_item['quality'], pp_item['durability'], 'prestige_points')
+        resp = self._post_economy_activate_booster(pp_item['quality'], pp_item['durability'], 'prestige_points').json()
+        self._update_inventory_data(resp)
+        return pp_item.get('kind') in self.inventory.active
 
     def _rw_choose_side(self, battle: classes.Battle, side: classes.BattleSide) -> Response:
         return self._post_main_battlefield_travel(side.id, battle.id)
@@ -2218,6 +2236,11 @@ class CitizenMilitary(CitizenTravel):
                 if division.wall['dom'] == 50 or division.wall['dom'] > 98:
                     yield division, division.wall['for'] == battle.invader.country.id
 
+    def report_fighting(self, battle: classes.Battle, invader: bool, division: classes.BattleDivision, damage: float, hits: int):
+        self.reporter.report_fighting(battle, invader, division, damage, hits)
+        if self.config.telegram:
+            self.telegram.report_fight(battle, invader, division, damage, hits)
+
 
 class CitizenPolitics(BaseCitizen):
     def get_country_parties(self, country: constants.Country = None) -> dict:
@@ -2371,6 +2394,12 @@ class CitizenTasks(CitizenEconomy):
     ot_points: int = 0
     next_ot_time: datetime = None
 
+    @property
+    def as_dict(self):
+        d = super().as_dict
+        d.update(tg_contract=self.tg_contract, ot_points=self.ot_points, next_ot_time=self.next_ot_time)
+        return d
+
     def eat(self):
         """ Eat food """
         self._eat("blue")
@@ -2498,8 +2527,8 @@ class CitizenTasks(CitizenEconomy):
             self.ot_points = ot.get("points", 0)
 
 
-class Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
-              CitizenMedia, CitizenPolitics, CitizenSocial, CitizenMilitary, CitizenTasks):
+class _Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
+               CitizenMedia, CitizenPolitics, CitizenSocial, CitizenMilitary, CitizenTasks):
     def __init__(self, email: str = "", password: str = "", auto_login: bool = False):
         super().__init__(email, password)
         self._last_full_update = constants.min_datetime
@@ -2510,10 +2539,18 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
     @classmethod
     def load_from_dump(cls, dump_name: str = ""):
         filename = dump_name if dump_name else f"{cls.__name__}__dump.json"
-        player: Citizen = super().load_from_dump(filename)  # noqa
+        player: _Citizen = super().load_from_dump(filename)  # noqa
         player.login()
         return player
 
+    def _eat(self, colour: str = "blue") -> Response:
+        resp = super()._eat(colour)
+        if not any([resp.json().get("units_consumed").values()]):
+            if colour == 'orange' and resp.json().get('food_remaining'):
+                self.eat()
+            return self._eat(colour)
+        return resp
+
     def config_setup(self, **kwargs):
         self.config.reset()
         for key, value in kwargs.items():
@@ -2674,10 +2711,12 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
             else:
                 start_time = utils.good_timedelta(start_time.replace(minute=0), timedelta(hours=1))
             while not self.stop_threads.is_set():
-                self.update_citizen_info()
                 start_time = utils.good_timedelta(start_time, timedelta(minutes=30))
+                self.update_citizen_info()
+                self.update_weekly_challenge()
                 self.send_state_update()
                 self.send_inventory_update()
+                self.update_companies()
                 self.send_my_companies_update()
                 sleep_seconds = (start_time - self.now).total_seconds()
                 self.stop_threads.wait(sleep_seconds if sleep_seconds > 0 else 0)
@@ -2869,3 +2908,161 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
                 self.stop_threads.wait(90)
             except:  # noqa
                 self.report_error('Command central is broken')
+
+
+class Citizen(_Citizen):
+    _concurrency_lock: Event
+    _update_lock: Event
+    _update_timeout: int = 10
+    _concurrency_timeout: int = 600
+
+    def __init__(self, *args, **kwargs):
+        self._concurrency_lock = Event()
+        self._concurrency_lock.set()
+        self._update_lock = Event()
+        self._update_lock.set()
+        super().__init__(*args, **kwargs)
+
+    def update_weekly_challenge(self):
+        if not self._update_lock.wait(self._update_timeout):
+            e = f'Update concurrency not freed in {self._update_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._update_lock.clear()
+            super().update_weekly_challenge()
+        finally:
+            self._update_lock.set()
+
+    def update_companies(self):
+        if not self._update_lock.wait(self._update_timeout):
+            e = f'Update concurrency not freed in {self._update_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._update_lock.clear()
+            super().update_companies()
+        finally:
+            self._update_lock.set()
+
+    def update_war_info(self):
+        if not self._update_lock.wait(self._update_timeout):
+            e = f'Update concurrency not freed in {self._update_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._update_lock.clear()
+            super().update_war_info()
+        finally:
+            self._update_lock.set()
+
+    def update_job_info(self):
+        if not self._update_lock.wait(self._update_timeout):
+            e = f'Update concurrency not freed in {self._update_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._update_lock.clear()
+            super().update_job_info()
+        finally:
+            self._update_lock.set()
+
+    def update_money(self, page: int = 0, currency: int = 62):
+        if not self._update_lock.wait(self._update_timeout):
+            e = f'Update concurrency not freed in {self._update_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._update_lock.clear()
+            super().update_money(page, currency)
+        finally:
+            self._update_lock.set()
+
+    def update_inventory(self):
+        if not self._update_lock.wait(self._update_timeout):
+            e = f'Update concurrency not freed in {self._update_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._update_lock.clear()
+            super().update_inventory()
+        finally:
+            self._update_lock.set()
+
+    def _work_as_manager(self, wam_holding: classes.Holding) -> Optional[Dict[str, Any]]:
+        if not self._concurrency_lock.wait(self._concurrency_timeout):
+            e = f'Concurrency not freed in {self._concurrency_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._concurrency_lock.clear()
+            return super()._work_as_manager(wam_holding)
+        finally:
+            self._concurrency_lock.set()
+
+    def fight(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide = None,
+              count: int = None, use_ebs: bool = False) -> Optional[int]:
+        if not self._concurrency_lock.wait(self._concurrency_timeout):
+            e = f'Concurrency not freed in {self._concurrency_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._concurrency_lock.clear()
+            return super().fight(battle, division, side, count, use_ebs)
+        finally:
+            self._concurrency_lock.set()
+
+    def deploy_bomb(self, battle: classes.Battle, division: classes.BattleDivision, bomb_id: int, inv_side: bool,
+                    count: int = 1) -> Optional[int]:
+        if not self._concurrency_lock.wait(self._concurrency_timeout):
+            e = f'Concurrency not freed in {self._concurrency_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._concurrency_lock.clear()
+            return super().deploy_bomb(battle, division, bomb_id, inv_side, count)
+        finally:
+            self._concurrency_lock.set()
+
+    def buy_market_offer(self, offer: OfferItem, amount: int = None) -> Optional[Dict[str, Any]]:
+        if not self._concurrency_lock.wait(self._concurrency_timeout):
+            e = f'Concurrency not freed in {self._concurrency_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._concurrency_lock.clear()
+            return super().buy_market_offer(offer, amount)
+        finally:
+            self._concurrency_lock.set()
+
+    @property
+    def as_dict(self):
+        d = super().as_dict
+        d.update(locks=dict(concurrency_lock=self._concurrency_lock.is_set(), update_lock=self._update_lock.is_set(),
+                            concurrency_timeout=self._concurrency_timeout, update_timeout=self._update_timeout))
+        return d
+
+    def set_locks(self):
+        super().set_locks()
+        self._concurrency_lock.set()
+        self._update_lock.set()

erepublik/classes.py

@@ -650,6 +650,16 @@ class Reporter:
                                          air=battle.has_air, hits=hits,
                                          round=battle.zone_id, extra=dict(battle=battle, side=side, division=division)))
 
+    def report_money_donation(self, citizen_id: int, amount: float, is_currency: bool = True):
+        cur = 'cc' if is_currency else 'gold'
+        self.report_action('DONATE_MONEY', dict(citizen_id=citizen_id, amount=amount, currency=cur),
+                           f"Successfully donated {amount}{cur} to citizen with id {citizen_id}!")
+
+    def report_item_donation(self, citizen_id: int, amount: float, quality: int, industry: str):
+        self.report_action('DONATE_ITEMS',
+                           dict(citizen_id=citizen_id, amount=amount, quality=quality, industry=industry),
+                           f"Successfully donated {amount} x {industry} q{quality} to citizen with id {citizen_id}!")
+
     def report_promo(self, kind: str, time_until: datetime.datetime):
         self._req.post(f"{self.url}/promos/add/", data=dict(kind=kind, time_untill=time_until))
 
@@ -974,7 +984,7 @@ class TelegramReporter:
         self._last_time = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-5))
         self._last_full_energy_report = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-30))
         if self.__queue:
-            self.send_message("\n\n––––––––––––––––––––––\n\n".join(self.__queue))
+            self.send_message("Telegram initialized")
 
     def send_message(self, message: str) -> bool:
         self.__queue.append(message)
@@ -1002,15 +1012,29 @@ class TelegramReporter:
         new_line = '\n' if multiple else ''
         self.send_message(f"New award: {new_line}*{msg}*")
 
+    def report_fight(self, battle: "Battle", invader: bool, division: "BattleDivision", damage: float, hits: int):
+        side_txt = (battle.invader if invader else battle.defender).country.iso
+        self.send_message(f"*Fight report*:\n{int(damage):,d} dmg ({hits} hits) in"
+                          f" [battle {battle.id} for {battle.region_name[:16]}]({battle.link}) in d{division.div} on "
+                          f"{side_txt} side")
+
+    def report_item_donation(self, citizen_id: int, amount: float, product: str):
+        self.send_message(f"*Donation*: {amount} x {product} to citizen "
+                          f"[{citizen_id}](https://www.erepublik.com/en/citizen/profile/{citizen_id})")
+
+    def report_money_donation(self, citizen_id: int, amount: float, is_currency: bool = True):
+        self.send_message(f"*Donation*: {amount}{'cc' if is_currency else 'gold'} to citizen "
+                          f"[{citizen_id}](https://www.erepublik.com/en/citizen/profile/{citizen_id})")
+
     def __send_messages(self):
         while self._next_time > utils.now():
             if self.__thread_stopper.is_set():
                 break
             self.__thread_stopper.wait(utils.get_sleep_seconds(self._next_time))
 
-        message = "\n\n––––––––––––––––––––––\n\n".join(self.__queue)
+        message = "\n\n".join(self.__queue)
         if self.player_name:
-            message = f"Player *{self.player_name}*\n" + message
+            message = f"Player *{self.player_name}*\n\n" + message
         response = post(self.api_url, json=dict(chat_id=self.chat_id, text=message, parse_mode="Markdown"))
         self._last_time = utils.now()
         if response.json().get('ok'):

requirements_dev.txt

@@ -13,7 +13,7 @@ pytest==6.2.1
 pytz>=2020.5
 requests>=2.25.1
 responses==0.12.1
-setuptools==51.1.1
-Sphinx==3.4.2
+setuptools==51.1.2
+Sphinx==3.4.3
 twine==3.3.0
 wheel==0.36.2

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.23.4.3
+current_version = 0.23.4.11
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)\.?(?P<dev>\d+)?

setup.py

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