Bump version: 0.23.3 → 0.23.3.1

erepublik/__init__.py

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

erepublik/access_points.py

@@ -15,10 +15,10 @@ class SlowRequests(Session):
     timeout: datetime.timedelta = datetime.timedelta(milliseconds=500)
     uas: List[str] = [
         # Chrome
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36',  # noqa
-        '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/86.0.4240.183 Safari/537.36',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) 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/81.0.4044.138 Safari/537.36',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) 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/86.0.4240.183 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',
@@ -29,14 +29,10 @@ class SlowRequests(Session):
         '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:81.0) Gecko/20100101 Firefox/81.0',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:80.0) Gecko/20100101 Firefox/80.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:79.0) Gecko/20100101 Firefox/79.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:83.0) Gecko/20100101 Firefox/83.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: bool = False
 
@@ -85,9 +81,10 @@ class SlowRequests(Session):
             if params:
                 args.update({"params": params})
 
-            body = "[{dt}]\tURL: '{url}'\tMETHOD: {met}\tARGS: {args}\n".format(dt=utils.now().strftime("%F %T"),
-                                                                                url=url, met=method, args=args)
-            utils.write_file(self.request_log_name, body)
+            body = f"[{utils.now().strftime('%F %T')}]\tURL: '{url}'\tMETHOD: {method}\tARGS: {args}\n"
+            with open(self.request_log_name, 'ab') as file:
+                file.write(body.encode("UTF-8"))
+            pass
 
     def _log_response(self, url, resp, redirect: bool = False):
         from erepublik import Citizen
@@ -97,22 +94,19 @@ class SlowRequests(Session):
                     self._log_request(hist_resp.request.url, "REDIRECT")
                     self._log_response(hist_resp.request.url, hist_resp, redirect=True)
 
-            file_data = {
-                "path": 'debug/requests',
-                "time": self.last_time.strftime('%Y/%m/%d/%H-%M-%S'),
-                "name": utils.slugify(url[len(Citizen.url):]),
-                "extra": "_REDIRECT" if redirect else ""
-            }
+            fd_path = 'debug/requests'
+            fd_time = self.last_time.strftime('%Y/%m/%d/%H-%M-%S')
+            fd_name = utils.slugify(url[len(Citizen.url):])
+            fd_extra = "_REDIRECT" if redirect else ""
 
             try:
                 utils.json.loads(resp.text)
-                file_data.update({"ext": "json"})
+                fd_ext = 'json'
             except utils.json.JSONDecodeError:
-                file_data.update({"ext": "html"})
+                fd_ext = 'html'
 
-            filename = 'debug/requests/{time}_{name}{extra}.{ext}'.format(**file_data)
-            with open(utils.get_file(filename), 'wb') as f:
-                f.write(resp.text.encode('utf-8'))
+            filename = f'{fd_path}/{fd_time}_{fd_name}{fd_extra}.{fd_ext}'
+            utils.write_file(filename, resp.text)
         pass
 
 
@@ -291,7 +285,6 @@ class ErepublikCountryAPI(CitizenBaseAPI):
 
     def _post_main_country_donate(self, country_id: int, action: str, value: Union[int, float],
                                   quality: int = None) -> Response:
-
         data = dict(countryId=country_id, action=action, _token=self.token, value=value, quality=quality)
         return self.post(f"{self.url}/main/country-donate", data=data,
                          headers={"Referer": f"{self.url}/country/economy/Latvia"})
@@ -366,16 +359,20 @@ class ErepublikEconomyAPI(CitizenBaseAPI):
 
 
 class ErepublikLeaderBoardAPI(CitizenBaseAPI):
-    def _get_main_leaderboards_damage_aircraft_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0) -> Response: # noqa
+    def _get_main_leaderboards_damage_aircraft_rankings(self, country_id: int, weeks: int = 0,
+                                                        mu_id: int = 0) -> Response:  # noqa
         return self.get(f"{self.url}/main/leaderboards-damage-aircraft-rankings/{country_id}/{weeks}/{mu_id}/0")
 
-    def _get_main_leaderboards_damage_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0, div: int = 0) -> Response: # noqa
+    def _get_main_leaderboards_damage_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0,
+                                               div: int = 0) -> Response:  # noqa
         return self.get(f"{self.url}/main/leaderboards-damage-rankings/{country_id}/{weeks}/{mu_id}/{div}")
 
-    def _get_main_leaderboards_kills_aircraft_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0) -> Response: # noqa
+    def _get_main_leaderboards_kills_aircraft_rankings(self, country_id: int, weeks: int = 0,
+                                                       mu_id: int = 0) -> Response:  # noqa
         return self.get(f"{self.url}/main/leaderboards-kills-aircraft-rankings/{country_id}/{weeks}/{mu_id}/0")
 
-    def _get_main_leaderboards_kills_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0, div: int = 0) -> Response: # noqa
+    def _get_main_leaderboards_kills_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0,
+                                              div: int = 0) -> Response:  # noqa
         return self.get(f"{self.url}/main/leaderboards-kills-rankings/{country_id}/{weeks}/{mu_id}/{div}")
 
 
@@ -441,8 +438,9 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
             data.update(page=page)
         return self.post(f"{self.url}/military/battle-console", data=data)
 
-    def _post_military_deploy_bomb(self, battle_id: int, bomb_id: int) -> Response:
-        data = dict(battleId=battle_id, bombId=bomb_id, _token=self.token)
+    def _post_military_deploy_bomb(self, battle_id: int, division_id: int, side_id: int, bomb_id: int) -> Response:
+        data = dict(battleId=battle_id, battleZoneId=division_id, sideId=side_id, sideCountryId=side_id,
+                    bombId=bomb_id, _token=self.token)
         return self.post(f"{self.url}/military/deploy-bomb", data=data)
 
     def _post_military_fight_air(self, battle_id: int, side_id: int, zone_id: int) -> Response:
@@ -486,7 +484,7 @@ class ErepublikPoliticsAPI(CitizenBaseAPI):
 class ErepublikPresidentAPI(CitizenBaseAPI):
     def _post_wars_attack_region(self, war_id: int, region_id: int, region_name: str) -> Response:
         data = {'_token': self.token, 'warId': war_id, 'regionName': region_name, 'regionNameConfirm': region_name}
-        return self.post('{}/wars/attack-region/{}/{}'.format(self.url, war_id, region_id), data=data)
+        return self.post(f'{self.url}/wars/attack-region/{war_id}/{region_id}', data=data)
 
     def _post_new_war(self, self_country_id: int, attack_country_id: int, debate: str = "") -> Response:
         data = dict(requirments=1, _token=self.token, debate=debate,

erepublik/citizen.py

@@ -43,7 +43,7 @@ class BaseCitizen(access_points.CitizenAPI):
     reporter: classes.Reporter = None
     stop_threads: Event = None
     concurrency_available: Event = None
-    telegram: classes.TelegramBot = None
+    telegram: classes.TelegramReporter = None
 
     r: Response = None
     name: str = "Not logged in!"
@@ -61,7 +61,7 @@ class BaseCitizen(access_points.CitizenAPI):
         self.stop_threads = Event()
         self.concurrency_available = Event()
         self.concurrency_available.set()
-        self.telegram = classes.TelegramBot(stop_event=self.stop_threads)
+        self.telegram = classes.TelegramReporter(stop_event=self.stop_threads)
 
         self.config.email = email
         self.config.password = password
@@ -607,8 +607,8 @@ class BaseCitizen(access_points.CitizenAPI):
             except AttributeError:
                 continue
         if data:
-            msgs = ["{count} x {kind}, totaling {} {currency}\n"
-                    "{about}".format(d["count"] * d["reward"], **d) for d in data.values()]
+            msgs = [f"{d['count']} x {d['kind']}, totaling {d['count'] * d['reward']} "
+                    f"{d['currency']}" for d in data.values()]
 
             msgs = "\n".join(msgs)
             if self.config.telegram:
@@ -1026,7 +1026,6 @@ class CitizenEconomy(CitizenTravel):
             ret.update({house_quality: till})
         return ret
 
-    @utils.wait_for_lock
     def buy_and_activate_house(self, q: int) -> Optional[Dict[int, datetime]]:
         original_region = self.details.current_country, self.details.current_region
         ok_to_activate = False
@@ -1040,14 +1039,22 @@ class CitizenEconomy(CitizenTravel):
 
             global_cheapest = self.get_market_offers("House", q)[f"q{q}"]
             if global_cheapest.price + 200 < local_cheapest.price:
-                if self.travel_to_country(global_cheapest.country):
-                    buy = self.buy_from_market(global_cheapest.offer_id, 1)
+                if global_cheapest.price + 2000 < self.details.cc:
+                    if self.travel_to_country(global_cheapest.country):
+                        buy = self.buy_market_offer(global_cheapest, 1)
+                    else:
+                        buy = dict(error=True, message='Unable to travel!')
                 else:
-                    buy = {'error': True, 'message': 'Unable to travel!'}
+                    buy = dict(error=True, message='Not enough money to buy house!')
             else:
-                buy = self.buy_from_market(local_cheapest.offer_id, 1)
-            if buy["error"]:
-                msg = f"Unable to buy q{q} house! \n{buy['message']}"
+                if local_cheapest.price < self.details.cc:
+                    buy = self.buy_market_offer(local_cheapest, 1)
+                else:
+                    buy = dict(error=True, message='Not enough money to buy house!')
+            if buy is None:
+                pass
+            elif buy["error"]:
+                msg = f'Unable to buy q{q} house! \n{buy["message"]}'
                 self.write_log(msg)
             else:
                 ok_to_activate = True
@@ -1151,11 +1158,13 @@ class CitizenEconomy(CitizenTravel):
         return False
 
     def post_market_offer(self, industry: int, quality: int, amount: int, price: float) -> bool:
+        if isinstance(industry, str):
+            industry = constants.INDUSTRIES[industry]
         if not constants.INDUSTRIES[industry]:
             self.write_log(f"Trying to sell unsupported industry {industry}")
 
         _inv_qlt = quality if industry in [1, 2, 3, 4, 23] else 0
-        _kind = 'final' if industry in [1, 2, 4, 4, 23] else 'raw'
+        _kind = 'final' if industry in [1, 2, 4, 23] else 'raw'
         inventory = self.get_inventory()
         items = inventory[_kind].get(constants.INDUSTRIES[industry], {_inv_qlt: {'amount': 0}})
         if items[_inv_qlt]['amount'] < amount:
@@ -1180,7 +1189,7 @@ class CitizenEconomy(CitizenTravel):
         self._report_action("ECONOMY_SELL_PRODUCTS", message, kwargs=ret)
         return not bool(ret.get('error', True))
 
-    def buy_from_market(self, offer: int, amount: int) -> dict:
+    def buy_from_market(self, offer: int, amount: int) -> Dict[str, Any]:
         ret = self._post_economy_marketplace_actions('buy', offer=offer, amount=amount)
         json_ret = ret.json()
         if not json_ret.get('error', True):
@@ -1198,13 +1207,7 @@ class CitizenEconomy(CitizenTravel):
         if not self.details.current_country == offer.country:
             traveled = True
             self.travel_to_country(offer.country)
-        ret = self._post_economy_marketplace_actions('buy', offer=offer.offer_id, amount=amount)
-        json_ret = ret.json()
-        if not json_ret.get('error', True):
-            self.details.cc = ret.json()['currency']
-            self.details.gold = ret.json()['gold']
-            json_ret.pop("offerUpdate", None)
-            self._report_action("BOUGHT_PRODUCTS", json_ret.get('message'), kwargs=json_ret)
+        json_ret = self.buy_from_market(offer.offer_id, amount)
         if traveled:
             self.travel_to_residence()
         return json_ret
@@ -1468,9 +1471,8 @@ class CitizenMedia(BaseCitizen):
                 article_id = 0
             return article_id
         else:
-            raise classes.ErepublikException("Article kind must be one of:\n{}\n'{}' is not supported".format(
-                "\n".join(["{}: {}".format(k, v) for k, v in kinds.items()]), kind
-            ))
+            kinds = "\n".join([f"{k}: {v}" for k, v in kinds.items()])
+            raise classes.ErepublikException(f"Article kind must be one of:\n{kinds}\n'{kind}' is not supported")
 
     def get_article(self, article_id: int) -> Dict[str, Any]:
         return self._get_main_article_json(article_id).json()
@@ -1687,21 +1689,24 @@ class CitizenMilitary(CitizenTravel):
         return bool(self.__last_war_update_data.get("citizen_contribution", []))
 
     def find_battle_to_fight(self, silent: bool = False) -> Tuple[
-        classes.Battle, classes.BattleDivision, classes.BattleSide]:
+        classes.Battle, classes.BattleDivision, classes.BattleSide
+    ]:
         self.update_war_info()
         for battle in self.sorted_battles(self.config.sort_battles_time):
             if not isinstance(battle, classes.Battle):
                 continue
+            if battle.is_dict_lib:
+                continue
             battle_zone: Optional[classes.BattleDivision] = None
             for div in battle.div.values():
                 if div.terrain == 0:
                     if div.div_end:
                         continue
+                    maverick_ok = self.maverick and self.config.maverick
                     if self.config.air and div.is_air:
                         battle_zone = div
                         break
-                    elif self.config.ground and not div.is_air and (
-                        div.div == self.division or (self.maverick and self.config.maverick)):
+                    elif self.config.ground and not div.is_air and (div.div == self.division or maverick_ok):
                         battle_zone = div
                         break
                     else:
@@ -1806,7 +1811,7 @@ class CitizenMilitary(CitizenTravel):
             else:
                 self._eat('blue')
                 if self.energy.recovered < 50 or error_count >= 10 or count <= 0:
-                    self.write_log("Hits: {:>4} | Damage: {}".format(total_hits, total_damage))
+                    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)
@@ -1843,6 +1848,9 @@ class CitizenMilitary(CitizenTravel):
             elif r_json.get("message") == "ZONE_INACTIVE":
                 self.write_log("Wrong division!!")
                 return 0, 10, 0
+            elif r_json.get("message") == "NON_BELLIGERENT":
+                self.write_log("Dictatorship/Liberation wars are not supported!")
+                return 0, 10, 0
             elif r_json.get("message") in ["FIGHT_DISABLED", "DEPLOYMENT_MODE"]:
                 self._post_main_profile_update('options',
                                                params='{"optionName":"enable_web_deploy","optionValue":"off"}')
@@ -1865,14 +1873,19 @@ class CitizenMilitary(CitizenTravel):
         return hits, err, damage
 
     @utils.wait_for_lock
-    def deploy_bomb(self, battle: classes.Battle, bomb_id: int, inv_side: bool = None, count: int = 1) -> Optional[int]:
+    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.
 
         :param battle: Battle
-        :type battle: Battle
+        :type battle: classes.Battle
+        :param division: BattleDivision
+        :type division: classes.BattleDivision
         :param bomb_id: int bomb id
-        :param inv_side: should deploy on invader side, if None then will deploy in currently available side
-        :param count: int how many bombs to deploy
+        :type bomb_id: int
+        :param inv_side: should deploy on invader side
+        :type inv_side: bool
+        :param count: how many bombs to deploy
+        :type count: int
         :return: Deployed count
         :rtype: int
         """
@@ -1887,18 +1900,15 @@ class CitizenMilitary(CitizenTravel):
             good_countries = [battle.invader.country] + battle.invader.deployed
             if self.details.current_country not in good_countries:
                 has_traveled = self.travel_to_battle(battle, good_countries)
-        elif inv_side is not None:
-            good_countries = [battle.defender.country] + battle.defender.deployed
-            if self.details.current_country not in good_countries:
-                has_traveled = self.travel_to_battle(battle, good_countries)
         else:
             involved = [battle.invader.country,
                         battle.defender.country] + battle.invader.deployed + battle.defender.deployed
             if self.details.current_country not in involved:
                 count = 0
+        side = battle.invader if inv_side else battle.defender
         errors = deployed_count = 0
         while (not deployed_count == count) and errors < 10:
-            r = self._post_military_deploy_bomb(battle.id, bomb_id).json()
+            r = self._post_military_deploy_bomb(battle.id, division.id, side.id, bomb_id).json()
             if not r.get('error'):
                 deployed_count += 1
             elif r.get('message') == 'LOCKED':
@@ -2308,7 +2318,7 @@ class CitizenTasks(BaseCitizen):
             self._eat("blue")
             if self.energy.food_fights < 1:
                 seconds = (self.energy.reference_time - self.now).total_seconds()
-                self.write_log("I don't have energy to work. Will sleep for {}s".format(seconds))
+                self.write_log(f"I don't have energy to work. Will sleep for {seconds}s")
                 self.sleep(seconds)
                 self._eat("blue")
             self.work()
@@ -2439,11 +2449,10 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
 
         self.update_citizen_info()
         self.reporter.do_init()
-        if self.config.telegram:
-            # noinspection SpellCheckingInspection
-            self.telegram.do_init(self.config.telegram_chat_id or 620981703,
-                                  self.config.telegram_token or "864251270:AAFzZZdjspI-kIgJVk4gF3TViGFoHnf8H4o",
-                                  "" if self.config.telegram_chat_id or self.config.telegram_token else self.name)
+        if self.config.telegram and self.config.telegram_chat_id:
+            self.telegram.do_init(self.config.telegram_chat_id,
+                                  self.config.telegram_token,
+                                  self.name)
             self.telegram.send_message(f"*Started* {utils.now():%F %T}")
 
         self.update_all(True)
@@ -2464,7 +2473,6 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
                 if self.details.gold >= 54:
                     self.buy_tg_contract()
                 else:
-
                     self.write_log(f"Training ground contract active but "
                                    f"don't have enough gold ({self.details.gold}g {self.details.cc}cc)")
         if self.energy.is_energy_full and self.config.telegram:
@@ -2501,8 +2509,8 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
                     data[(title, reward)]['count'] += count
             self._post_main_global_alerts_close(medal.get('id'))
         if data:
-            msgs = ["{count} x {kind},"
-                    " totaling {} {currency}".format(d["count"] * d["reward"], **d) for d in data.values()]
+            msgs = [f"{d['count']} x {d['kind']}, totaling {d['count'] * d['reward']} "
+                    f"{d['currency']}" for d in data.values()]
 
             msgs = "\n".join(msgs)
             if self.config.telegram:
@@ -2635,7 +2643,7 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
         if not amount:
             inv_resp = self._get_economy_inventory_items().json()
             category = "rawMaterials" if kind.endswith("Raw") else "finalProducts"
-            item = "{}_{}".format(constants.INDUSTRIES[kind], quality)
+            item = f"{constants.INDUSTRIES[kind]}_{quality}"
             amount = inv_resp.get("inventoryItems").get(category).get("items").get(item).get("amount", 0)
 
         if amount >= 1:
@@ -2664,7 +2672,7 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
                         elif kind.endswith("Raw"):
                             self.sell_produced_product(kind, 1)
                         else:
-                            raise classes.ErepublikException("Unknown kind produced '{kind}'".format(kind=kind))
+                            raise classes.ErepublikException(f"Unknown kind produced '{kind}'")
         elif self.config.auto_buy_raw and re.search(r"not_enough_[^_]*_raw", response.get("message")):
             raw_kind = re.search(r"not_enough_(\w+)_raw", response.get("message"))
             if raw_kind:
@@ -2710,7 +2718,7 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
             self._report_action("WORK_AS_MANAGER", "Not enough money to work as manager!", kwargs=response)
             self.write_log("Not enough money to work as manager!")
         else:
-            msg = "I was not able to wam and or employ because:\n{}".format(response)
+            msg = f"I was not able to wam and or employ because:\n{response}"
             self._report_action("WORK_AS_MANAGER", f"Worked as manager failed: {msg}", kwargs=response)
             self.write_log(msg)
 
@@ -2749,7 +2757,7 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
 
             wam_count = self.my_companies.get_total_wam_count()
             if wam_count:
-                self.write_log("Wam ff lockdown is now {}, was {}".format(wam_count, self.my_companies.ff_lockdown))
+                self.write_log(f"Wam ff lockdown is now {wam_count}, was {self.my_companies.ff_lockdown}")
             self.my_companies.ff_lockdown = wam_count
             self.travel_to_residence()
             return bool(wam_count)

erepublik/classes.py

@@ -10,7 +10,8 @@ from requests import Response, Session, post
 from . import utils, constants
 
 __all__ = ['Battle', 'BattleDivision', 'BattleSide', 'Company', 'Config', 'Details', 'Energy', 'ErepublikException',
-           'Holding', 'MyCompanies', 'MyJSONEncoder', 'OfferItem', 'Politics', 'Reporter', 'TelegramBot']
+           'ErepublikNetworkException', 'EnergyToFight',
+           'Holding', 'MyCompanies', 'MyJSONEncoder', 'OfferItem', 'Politics', 'Reporter', 'TelegramReporter']
 
 
 class ErepublikException(Exception):
@@ -419,7 +420,7 @@ class Energy:
         self._recovery_time = utils.now()
 
     def __repr__(self):
-        return "{:4}/{:4} + {:4}, {:3}hp/6min".format(self.recovered, self.limit, self.recoverable, self.interval)
+        return f"{self.recovered:4}/{self.limit:4} + {self.recoverable:4}, {self.interval:3}hp/6min"
 
     def set_reference_time(self, recovery_time: datetime.datetime):
         self._recovery_time = recovery_time.replace(microsecond=0)
@@ -598,10 +599,10 @@ class Reporter:
             for unreported_data in self.__to_update:
                 unreported_data.update(player_id=self.citizen_id, key=self.key)
                 unreported_data = utils.json.loads(utils.json.dumps(unreported_data, cls=MyJSONEncoder))
-                self._req.post("{}/bot/update".format(self.url), json=unreported_data)
+                self._req.post(f"{self.url}/bot/update", json=unreported_data)
             self.__to_update.clear()
         data = utils.json.loads(utils.json.dumps(data, cls=MyJSONEncoder))
-        r = self._req.post("{}/bot/update".format(self.url), json=data)
+        r = self._req.post(f"{self.url}/bot/update", json=data)
         return r
 
     def register_account(self):
@@ -609,8 +610,8 @@ class Reporter:
             try:
                 r = self.__bot_update(dict(key=self.key, check=True, player_id=self.citizen_id))
                 if not r.json().get("status"):
-                    self._req.post("{}/bot/register".format(self.url), json=dict(name=self.name, email=self.email,
-                                                                                 player_id=self.citizen_id))
+                    self._req.post(f"{self.url}/bot/register", json=dict(name=self.name, email=self.email,
+                                                                         player_id=self.citizen_id))
             finally:
                 self.__registered = True
                 self.allowed = True
@@ -895,9 +896,9 @@ class Battle:
         time_now = utils.now()
         is_started = self.start < utils.now()
         if is_started:
-            time_part = " {}".format(time_now - self.start)
+            time_part = f" {time_now - self.start}"
         else:
-            time_part = "-{}".format(self.start - time_now)
+            time_part = f"-{self.start - time_now}"
 
         return (f"Battle {self.id} for {self.region_name[:16]:16} | "
                 f"{self.invader} : {self.defender} | Round time {time_part} | {'R'+str(self.zone_id):>3}")
@@ -937,7 +938,7 @@ class EnergyToFight:
         return self.energy
 
 
-class TelegramBot:
+class TelegramReporter:
     __initialized: bool = False
     __queue: List[str]
     chat_id: int = 0
@@ -962,10 +963,12 @@ class TelegramBot:
                 'last_time': self._last_time, 'next_time': self._next_time, 'queue': self.__queue,
                 'initialized': self.__initialized, 'has_threads': not self._threads}
 
-    def do_init(self, chat_id: int, token: str, player_name: str = ""):
+    def do_init(self, chat_id: int, token: str = None, player_name: str = None):
+        if token is None:
+            token = "864251270:AAFzZZdjspI-kIgJVk4gF3TViGFoHnf8H4o"
         self.chat_id = chat_id
-        self.api_url = "https://api.telegram.org/bot{}/sendMessage".format(token)
-        self.player_name = player_name
+        self.api_url = f"https://api.telegram.org/bot{token}/sendMessage"
+        self.player_name = player_name or ""
         self.__initialized = True
         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))
@@ -981,7 +984,7 @@ class TelegramBot:
         self._threads = [t for t in self._threads if t.is_alive()]
         self._next_time = utils.good_timedelta(utils.now(), datetime.timedelta(seconds=20))
         if not self._threads:
-            name = "telegram_{}send".format(f"{self.player_name}_" if self.player_name else "")
+            name = f"telegram_{f'{self.player_name}_' if self.player_name else ''}send"
             send_thread = threading.Thread(target=self.__send_messages, name=name)
             send_thread.start()
             self._threads.append(send_thread)
@@ -1016,7 +1019,7 @@ class TelegramBot:
 
 
 class OfferItem(NamedTuple):
-    price: float = 99_999.
+    price: float = 999_999_999.
     country: constants.Country = constants.Country(0, "", "", "")
     amount: int = 0
     offer_id: int = 0

erepublik/utils.py

@@ -21,11 +21,11 @@ try:
 except ImportError:
     import json
 
-__all__ = ['VERSION', 'calculate_hit', 'caught_error', 'date_from_eday', 'eday_from_date',
+__all__ = ['VERSION', 'calculate_hit', 'caught_error', 'date_from_eday', 'eday_from_date', 'deprecation',
            'get_air_hit_dmg_value', 'get_file', 'get_ground_hit_dmg_value', 'get_sleep_seconds', 'good_timedelta',
            'interactive_sleep', 'json', 'localize_dt', 'localize_timestamp', 'normalize_html_json', 'now',
-           'process_error', 'process_warning', 'send_email', 'silent_sleep', 'slugify', 'write_file',
-           'write_interactive_log', 'write_silent_log']
+           'process_error', 'process_warning', 'send_email', 'silent_sleep', 'slugify', 'write_file', 'write_request',
+           'write_interactive_log', 'write_silent_log', 'get_final_hit_dmg', 'wait_for_lock']
 
 if not sys.version_info >= (3, 6):
     raise AssertionError('This script requires Python version 3.6 and higher\n'
@@ -93,7 +93,7 @@ def interactive_sleep(sleep_seconds: int):
         #     seconds = seconds % 30 if seconds % 30 else 30
         else:
             seconds = 1
-        sys.stdout.write("\rSleeping for {:4} more seconds".format(sleep_seconds))
+        sys.stdout.write(f"\rSleeping for {sleep_seconds:4} more seconds")
         sys.stdout.flush()
         time.sleep(seconds)
         sleep_seconds -= seconds
@@ -105,7 +105,7 @@ silent_sleep = time.sleep
 
 def _write_log(msg, timestamp: bool = True, should_print: bool = False):
     erep_time_now = now()
-    txt = "[{}] {}".format(erep_time_now.strftime('%F %T'), msg) if timestamp else msg
+    txt = f"[{erep_time_now.strftime('%F %T')}] {msg}" if timestamp else msg
     txt = "\n".join(["\n".join(textwrap.wrap(line, 120)) for line in txt.splitlines()])
     if not os.path.isdir('log'):
         os.mkdir('log')
@@ -172,10 +172,10 @@ def write_request(response: requests.Response, is_error: bool = False):
         ext = "html"
 
     if not is_error:
-        filename = "debug/requests/{}_{}.{}".format(now().strftime('%F_%H-%M-%S'), name, ext)
+        filename = f"debug/requests/{now().strftime('%F_%H-%M-%S')}_{name}.{ext}"
         write_file(filename, html)
     else:
-        return {"name": "{}_{}.{}".format(now().strftime('%F_%H-%M-%S'), name, ext),
+        return {"name": f"{now().strftime('%F_%H-%M-%S')}_{name}.{ext}",
                 "content": html.encode('utf-8'),
                 "mimetype": "application/json" if ext == "json" else "text/html"}
 
@@ -196,14 +196,14 @@ def send_email(name: str, content: List[Any], player=None, local_vars: Dict[str,
     if promo:
         resp = {"name": "%s.html" % name, "mimetype": "text/html",
                 "content": file_content_template.format(title="Promo", body="<br/>".join(content))}
-        subject = "[eBot][{}] Promos: {}".format(now().strftime('%F %T'), name)
+        subject = f"[eBot][{now().strftime('%F %T')}] Promos: {name}"
 
     elif captcha:
         resp = {"name": "%s.html" % name, "mimetype": "text/html",
                 "content": file_content_template.format(title="ReCaptcha", body="<br/>".join(content))}
-        subject = "[eBot][{}] RECAPTCHA: {}".format(now().strftime('%F %T'), name)
+        subject = f"[eBot][{now().strftime('%F %T')}] RECAPTCHA: {name}"
     else:
-        subject = "[eBot][%s] Bug trace: %s" % (now().strftime('%F %T'), name)
+        subject = f"[eBot][{now().strftime('%F %T')}] Bug trace: {name}"
 
     body = "".join(traceback.format_stack()) + \
            "\n\n" + \

examples/battle_launcher.py

@@ -97,7 +97,7 @@ def main():
     player.set_debug(CONFIG.get('debug', False))
     player.login()
     if CONFIG.get('battle_launcher'):
-        name = "{}-battle_launcher-{}".format(player.name, threading.active_count() - 1)
+        name = f"{player.name}-battle_launcher-{threading.active_count() - 1}"
         state_thread = threading.Thread(target=_battle_launcher, args=(player,), name=name)
         state_thread.start()
 

examples/eat_work_train.py

@@ -94,15 +94,15 @@ def main():
             closest_next_time = dt_max
             next_tasks = []
             for task, next_time in sorted(tasks.items(), key=lambda s: s[1]):
-                next_tasks.append("{}: {}".format(next_time.strftime('%F %T'), task))
+                next_tasks.append(f"{next_time.strftime('%F %T')}: {task}")
                 if next_time < closest_next_time:
                     closest_next_time = next_time
             sleep_seconds = int(utils.get_sleep_seconds(closest_next_time))
             if sleep_seconds <= 0:
                 player.write_log(f"Loop detected! Offending task: '{next_tasks[0]}'")
             player.write_log("My next Tasks and there time:\n" + "\n".join(sorted(next_tasks)))
-            player.write_log("Sleeping until (eRep): {} (sleeping for {}s)".format(
-                closest_next_time.strftime("%F %T"), sleep_seconds))
+            player.write_log(f"Sleeping until (eRep): {closest_next_time.strftime('%F %T')}"
+                             f" (sleeping for {sleep_seconds}s)")
             seconds_to_sleep = sleep_seconds if sleep_seconds > 0 else 0
             player.sleep(seconds_to_sleep)
         except Exception as e:

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.23.2.4
+current_version = 0.23.3.1
 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.2.4',
+    version='0.23.3.1',
     zip_safe=False,
 )