Bump version: 0.21.0.3 → 0.21.1

Add a Codacy badge to README.rst

README.rst

@@ -10,6 +10,10 @@ eRepublik script
         :target: https://erepublik.readthedocs.io/en/latest/?badge=latest
         :alt: Documentation Status
 
+.. image:: https://api.codacy.com/project/badge/Grade/eaa7ae43d23f4c0abab65c3bde89475a
+        :target: https://app.codacy.com/manual/eeriks/erepublik?utm_source=github.com&utm_medium=referral&utm_content=eeriks/erepublik&utm_campaign=Badge_Grade_Dashboard
+        :alt: Codacy Badge
+
 
 Python package for automated eRepublik playing
 
@@ -30,3 +34,4 @@ This package was created with Cookiecutter_ and the `audreyr/cookiecutter-pypack
 
 .. _Cookiecutter: https://github.com/audreyr/cookiecutter
 .. _`audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackage
+

erepublik/__init__.py

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

erepublik/access_points.py

@@ -132,23 +132,23 @@ class CitizenBaseAPI:
 
 class ErepublikAnniversaryAPI(CitizenBaseAPI):
     def _post_main_collect_anniversary_reward(self) -> Response:
-        return self.post("{}/main/collect-anniversary-reward".format(self.url), data={"_token": self.token})
+        return self.post(f"{self.url}/main/collect-anniversary-reward", data={"_token": self.token})
 
     # 12th anniversary endpoints
     def _get_anniversary_quest_data(self) -> Response:
-        return self.get("{}/main/anniversaryQuestData".format(self.url))
+        return self.get(f"{self.url}/main/anniversaryQuestData")
 
     def _post_map_rewards_unlock(self, node_id: int) -> Response:
         data = {'nodeId': node_id, '_token': self.token}
-        return self.post("{}/main/map-rewards-unlock".format(self.url), data=data)
+        return self.post(f"{self.url}/main/map-rewards-unlock", data=data)
 
     def _post_map_rewards_speedup(self, node_id: int, currency_amount: int) -> Response:
         data = {'nodeId': node_id, '_token': self.token, "currencyCost": currency_amount}
-        return self.post("{}/main/map-rewards-speedup".format(self.url), data=data)
+        return self.post(f"{self.url}/main/map-rewards-speedup", data=data)
 
     def _post_map_rewards_claim(self, node_id: int) -> Response:
         data = {'nodeId': node_id, '_token': self.token}
-        return self.post("{}/main/map-rewards-claim".format(self.url), data=data)
+        return self.post(f"{self.url}/main/map-rewards-claim", data=data)
 
     def _post_main_wheel_of_fortune_spin(self, cost) -> Response:
         return self.post(f"{self.url}/wheeloffortune-spin", data={'_token': self.token, "cost": cost})
@@ -159,52 +159,52 @@ class ErepublikAnniversaryAPI(CitizenBaseAPI):
 
 class ErepublikArticleAPI(CitizenBaseAPI):
     def _get_main_article_json(self, article_id: int) -> Response:
-        return self.get("{}/main/articleJson/{}".format(self.url, article_id))
+        return self.get(f"{self.url}/main/articleJson/{article_id}")
 
-    def _post_main_article_comments(self, article: int, page: int = 1) -> Response:
+    def _post_main_article_comments(self, article_id: int, page: int = 1) -> Response:
-        data = dict(_token=self.token, articleId=article, page=page)
+        data = dict(_token=self.token, articleId=article_id, page=page)
         if page:
             data.update({'page': page})
-        return self.post("{}/main/articleComments".format(self.url), data=data)
+        return self.post(f"{self.url}/main/articleComments", data=data)
 
-    def _post_main_article_comments_create(self, message: str, article: int, parent: int = 0) -> Response:
+    def _post_main_article_comments_create(self, message: str, article_id: int, parent: int = 0) -> Response:
-        data = dict(_token=self.token, message=message, articleId=article)
+        data = dict(_token=self.token, message=message, articleId=article_id)
         if parent:
             data.update({"parentId": parent})
-        return self.post("{}/main/articleComments/create".format(self.url), data=data)
+        return self.post(f"{self.url}/main/articleComments/create", data=data)
 
     def _post_main_donate_article(self, article_id: int, amount: int) -> Response:
         data = dict(_token=self.token, articleId=article_id, amount=amount)
-        return self.post("{}/main/donate-article".format(self.url), data=data)
+        return self.post(f"{self.url}/main/donate-article", data=data)
 
-    def _post_main_write_article(self, title: str, content: str, country: int, kind: int) -> Response:
+    def _post_main_write_article(self, title: str, content: str, country_id: int, kind_id: int) -> Response:
-        data = dict(_token=self.token, article_name=title, article_body=content, article_location=country,
+        data = dict(_token=self.token, article_name=title, article_body=content, article_location=country_id,
-                    article_category=kind)
+                    article_category=kind_id)
-        return self.post("{}/main/write-article".format(self.url), data=data)
+        return self.post(f"{self.url}/main/write-article", data=data)
 
     def _post_main_vote_article(self, article_id: int) -> Response:
         data = dict(_token=self.token, articleId=article_id)
-        return self.post("{}/main/vote-article".format(self.url), data=data)
+        return self.post(f"{self.url}/main/vote-article", data=data)
 
 
 class ErepublikCompanyAPI(CitizenBaseAPI):
-    def _post_economy_assign_to_holding(self, factory: int, holding: int) -> Response:
+    def _post_economy_assign_to_holding(self, factory_id: int, holding_id: int) -> Response:
-        data = dict(_token=self.token, factoryId=factory, action="assign", holdingCompanyId=holding)
+        data = dict(_token=self.token, factoryId=factory_id, action="assign", holdingCompanyId=holding_id)
-        return self.post("{}/economy/assign-to-holding".format(self.url), data=data)
+        return self.post(f"{self.url}/economy/assign-to-holding", data=data)
 
-    def _post_economy_create_company(self, industry: int, building_type: int = 1) -> Response:
+    def _post_economy_create_company(self, industry_id: int, building_type: int = 1) -> Response:
-        data = {"_token": self.token, "company[industry_id]": industry, "company[building_type]": building_type}
+        data = {"_token": self.token, "company[industry_id]": industry_id, "company[building_type]": building_type}
-        return self.post("{}/economy/create-company".format(self.url), data=data,
+        return self.post(f"{self.url}/economy/create-company", data=data,
-                         headers={"Referer": "{}/economy/create-company".format(self.url)})
+                         headers={"Referer": f"{self.url}/economy/create-company"})
 
     def _get_economy_inventory_items(self) -> Response:
-        return self.get("{}/economy/inventory-items/".format(self.url))
+        return self.get(f"{self.url}/economy/inventory-items/")
 
-    def _get_economy_job_market_json(self, country: int) -> Response:
+    def _get_economy_job_market_json(self, country_id: int) -> Response:
-        return self.get("{}/economy/job-market-json/{}/1/desc".format(self.url, country))
+        return self.get(f"{self.url}/economy/job-market-json/{country_id}/1/desc")
 
     def _get_economy_my_companies(self) -> Response:
-        return self.get("{}/economy/myCompanies".format(self.url))
+        return self.get(f"{self.url}/economy/myCompanies")
 
     def _post_economy_train(self, tg_ids: List[int]) -> Response:
         data: Dict[str, Union[int, str]] = {}
@@ -213,11 +213,11 @@ class ErepublikCompanyAPI(CitizenBaseAPI):
             data["grounds[%i][train]" % idx] = 1
         if data:
             data['_token'] = self.token
-        return self.post("{}/economy/train".format(self.url), data=data)
+        return self.post(f"{self.url}/economy/train", data=data)
 
     def _post_economy_upgrade_company(self, factory: int, level: int, pin: str = None) -> Response:
         data = dict(_token=self.token, type="upgrade", companyId=factory, level=level, pin="" if pin is None else pin)
-        return self.post("{}/economy/upgrade-company".format(self.url), data=data)
+        return self.post(f"{self.url}/economy/upgrade-company", data=data)
 
     def _post_economy_work(self, action_type: str, wam: List[int] = None, employ: Dict[int, int] = None) -> Response:
         data: Dict[str, Union[int, str]] = dict(action_type=action_type, _token=self.token)
@@ -241,174 +241,169 @@ class ErepublikCompanyAPI(CitizenBaseAPI):
                     f"companies[{max_idx}][own_work]": 0
                 })
                 max_idx += 1
-        return self.post("{}/economy/work".format(self.url), data=data)
+        return self.post(f"{self.url}/economy/work", data=data)
 
     def _post_economy_work_overtime(self) -> Response:
         data = dict(action_type="workOvertime", _token=self.token)
-        return self.post("{}/economy/workOvertime".format(self.url), data=data)
+        return self.post(f"{self.url}/economy/workOvertime", data=data)
 
-    def _post_economy_job_market_apply(self, citizen: int, salary: float) -> Response:
+    def _post_economy_job_market_apply(self, citizen_id: int, salary: float) -> Response:
-        data = dict(_token=self.token, citizenId=citizen, salary=salary)
+        data = dict(_token=self.token, citizenId=citizen_id, salary=salary)
-        return self.post("{}/economy/job-market-apply".format(self.url), data=data)
+        return self.post(f"{self.url}/economy/job-market-apply", data=data)
 
     def _post_economy_resign(self) -> Response:
-        return self.post("{}/economy/resign".format(self.url),
+        return self.post(f"{self.url}/economy/resign",
                          headers={"Content-Type": "application/x-www-form-urlencoded"},
                          data={"_token": self.token, "action_type": "resign"})
 
-    def _post_economy_sell_company(self, factory: int, pin: int = None, sell: bool = True) -> Response:
+    def _post_economy_sell_company(self, factory_id: int, pin: int = None, sell: bool = True) -> Response:
         data = dict(_token=self.token, pin="" if pin is None else pin)
         if sell:
             data.update({"sell": "sell"})
         else:
-            data.update({"dissolve": factory})
+            data.update({"dissolve": factory_id})
-        return self.post("{}/economy/sell-company/{}".format(self.url, factory),
+        return self.post(f"{self.url}/economy/sell-company/{factory_id}",
                          data=data, headers={"Referer": self.url})
 
 
 class ErepublikCountryAPI(CitizenBaseAPI):
-    def _get_country_military(self, country: str) -> Response:
+    def _get_country_military(self, country_name: str) -> Response:
-        return self.get("{}/country/military/{}".format(self.url, country))
+        return self.get(f"{self.url}/country/military/{country_name}")
 
-    def _post_main_country_donate(self, country: int, action: str, value: Union[int, float],
+    def _post_main_country_donate(self, country_id: int, action: str, value: Union[int, float],
                                   quality: int = None) -> Response:
-        json = dict(countryId=country, action=action, _token=self.token, value=value, quality=quality)
+
-        return self.post("{}/main/country-donate".format(self.url), data=json,
+        data = dict(countryId=country_id, action=action, _token=self.token, value=value, quality=quality)
-                         headers={"Referer": "{}/country/economy/Latvia".format(self.url)})
+        return self.post(f"{self.url}/main/country-donate", data=data,
+                         headers={"Referer": f"{self.url}/country/economy/Latvia"})
 
 
 class ErepublikEconomyAPI(CitizenBaseAPI):
     def _get_economy_citizen_accounts(self, organisation_id: int) -> Response:
-        return self.get("{}/economy/citizen-accounts/{}".format(self.url, organisation_id))
+        return self.get(f"{self.url}/economy/citizen-accounts/{organisation_id}")
 
     def _get_economy_my_market_offers(self) -> Response:
-        return self.get("{}/economy/myMarketOffers".format(self.url))
+        return self.get(f"{self.url}/economy/myMarketOffers")
 
     def _get_main_job_data(self) -> Response:
-        return self.get("{}/main/job-data".format(self.url))
+        return self.get(f"{self.url}/main/job-data")
 
     def _post_main_buy_gold_items(self, currency: str, item: str, amount: int) -> Response:
         data = dict(itemId=item, currency=currency, amount=amount, _token=self.token)
-        return self.post("{}/main/buyGoldItems".format(self.url), data=data)
+        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)
-        return self.post("{}/economy/activateBooster".format(self.url), data=data)
+        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}
-        return self.post("{}/economy/activateHouse".format(self.url), data=data)
+        return self.post(f"{self.url}/economy/activateHouse", data=data)
 
-    def _post_economy_donate_items_action(self, citizen: int, amount: int, industry: int,
+    def _post_economy_donate_items_action(self, citizen_id: int, amount: int, industry: int,
                                           quality: int) -> Response:
-        data = dict(citizen_id=citizen, amount=amount, industry_id=industry, quality=quality, _token=self.token)
+        data = dict(citizen_id=citizen_id, amount=amount, industry_id=industry, quality=quality, _token=self.token)
-        return self.post("{}/economy/donate-items-action".format(self.url), data=data,
+        return self.post(f"{self.url}/economy/donate-items-action", data=data,
-                         headers={"Referer": "{}/economy/donate-items/{}".format(self.url, citizen)})
+                         headers={"Referer": f"{self.url}/economy/donate-items/{citizen_id}"})
 
-    def _post_economy_donate_money_action(self, citizen: int, amount: float = 0.0,
+    def _post_economy_donate_money_action(self, citizen_id: int, amount: float = 0.0,
                                           currency: int = 62) -> Response:
-        data = dict(citizen_id=citizen, _token=self.token, currency_id=currency, amount=amount)
+        data = dict(citizen_id=citizen_id, _token=self.token, currency_id=currency, amount=amount)
-        return self.post("{}/economy/donate-money-action".format(self.url), data=data,
+        return self.post(f"{self.url}/economy/donate-money-action", data=data,
-                         headers={"Referer": "{}/economy/donate-money/{}".format(self.url, citizen)})
+                         headers={"Referer": f"{self.url}/economy/donate-money/{citizen_id}"})
 
     def _post_economy_exchange_purchase(self, amount: float, currency: int, offer: int) -> Response:
         data = dict(_token=self.token, amount=amount, currencyId=currency, offerId=offer)
-        return self.post("{}/economy/exchange/purchase/".format(self.url), data=data)
+        return self.post(f"{self.url}/economy/exchange/purchase/", data=data)
 
     def _post_economy_exchange_retrieve(self, personal: bool, page: int, currency: int) -> Response:
         data = dict(_token=self.token, personalOffers=int(personal), page=page, currencyId=currency)
-        return self.post("{}/economy/exchange/retrieve/".format(self.url), data=data)
+        return self.post(f"{self.url}/economy/exchange/retrieve/", data=data)
 
     def _post_economy_game_tokens_market(self, action: str) -> Response:
         assert action in ['retrieve', ]
         data = dict(_token=self.token, action=action)
-        return self.post("{}/economy/gameTokensMarketAjax".format(self.url), data=data)
+        return self.post(f"{self.url}/economy/gameTokensMarketAjax", data=data)
 
     def _post_economy_marketplace(self, country: int, industry: int, quality: int,
                                   order_asc: bool = True) -> Response:
         data = dict(countryId=country, industryId=industry, quality=quality, ajaxMarket=1,
                     orderBy="price_asc" if order_asc else "price_desc", _token=self.token)
-        return self.post("{}/economy/marketplaceAjax".format(self.url), data=data)
+        return self.post(f"{self.url}/economy/marketplaceAjax", data=data)
 
     def _post_economy_marketplace_actions(self, amount: int, buy: bool = False, **kwargs) -> Response:
         if buy:
             data = dict(_token=self.token, offerId=kwargs['offer'], amount=amount, orderBy="price_asc", currentPage=1,
                         buyAction=1)
         else:
-            data = dict(_token=self.token, countryId=kwargs["country"], price=kwargs["price"],
+            data = dict(_token=self.token, countryId=kwargs["country_id"], price=kwargs["price"],
                         industryId=kwargs["industry"], quality=kwargs["quality"], amount=amount, sellAction='postOffer')
-        return self.post("{}/economy/marketplaceActions".format(self.url), data=data)
+        return self.post(f"{self.url}/economy/marketplaceActions", data=data)
 
 
 class ErepublikLeaderBoardAPI(CitizenBaseAPI):
-    def _get_main_leaderboards_damage_aircraft_rankings(self, country: int, weeks: int = 0, mu: int = 0) -> Response:
+    def _get_main_leaderboards_damage_aircraft_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0) -> Response:
-        data = (country, weeks, mu)
+        return self.get(f"{self.url}/main/leaderboards-damage-aircraft-rankings/{country_id}/{weeks}/{mu_id}/0")
-        return self.get("{}/main/leaderboards-damage-aircraft-rankings/{}/{}/{}/0".format(self.url, *data))
 
-    def _get_main_leaderboards_damage_rankings(self, country: int, weeks: int = 0, mu: int = 0,
+    def _get_main_leaderboards_damage_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0, div: int = 0) -> Response:
-                                               div: int = 0) -> Response:
+        return self.get(f"{self.url}/main/leaderboards-damage-rankings/{country_id}/{weeks}/{mu_id}/{div}")
-        data = (country, weeks, mu, div)
-        return self.get("{}/main/leaderboards-damage-rankings/{}/{}/{}/{}".format(self.url, *data))
 
-    def _get_main_leaderboards_kills_aircraft_rankings(self, country: int, weeks: int = 0, mu: int = 0) -> Response:
+    def _get_main_leaderboards_kills_aircraft_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0) -> Response:
-        data = (country, weeks, mu)
+        return self.get(f"{self.url}/main/leaderboards-kills-aircraft-rankings/{country_id}/{weeks}/{mu_id}/0")
-        return self.get("{}/main/leaderboards-kills-aircraft-rankings/{}/{}/{}/0".format(self.url, *data))
 
-    def _get_main_leaderboards_kills_rankings(self, country: int, weeks: int = 0, mu: int = 0,
+    def _get_main_leaderboards_kills_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0, div: int = 0) -> Response:
-                                              div: int = 0) -> Response:
+        return self.get(f"{self.url}/main/leaderboards-kills-rankings/{country_id}/{weeks}/{mu_id}/{div}")
-        data = (country, weeks, mu, div)
-        return self.get("{}/main/leaderboards-kills-rankings/{}/{}/{}/{}".format(self.url, *data))
 
 
 class ErepublikLocationAPI(CitizenBaseAPI):
-    def _get_main_city_data_residents(self, city: int, page: int = 1, params: Mapping[str, Any] = None) -> Response:
+    def _get_main_city_data_residents(self, city_id: int, page: int = 1, params: Mapping[str, Any] = None) -> Response:
         if params is None:
             params = {}
-        return self.get("{}/main/city-data/{}/residents".format(self.url, city), params={"currentPage": page, **params})
+        return self.get(f"{self.url}/main/city-data/{city_id}/residents", params={"currentPage": page, **params})
 
 
 class ErepublikMilitaryAPI(CitizenBaseAPI):
-    def _get_military_battlefield_choose_side(self, battle: int, side: int) -> Response:
+    def _get_military_battlefield_choose_side(self, battle_id: int, side_id: int) -> Response:
-        return self.get("{}/military/battlefield-choose-side/{}/{}".format(self.url, battle, side))
+        return self.get(f"{self.url}/military/battlefield-choose-side/{battle_id}/{side_id}")
 
-    def _get_military_show_weapons(self, battle: int) -> Response:
+    def _get_military_show_weapons(self, battle_id: int) -> Response:
-        return self.get("{}/military/show-weapons".format(self.url), params={'_token': self.token, 'battleId': battle})
+        return self.get(f"{self.url}/military/show-weapons", params={'_token': self.token, 'battleId': battle_id})
 
     def _get_military_campaigns(self) -> Response:
-        return self.get("{}/military/campaigns-new/".format(self.url))
+        return self.get(f"{self.url}/military/campaigns-new/")
 
     def _get_military_campaigns_json_list(self) -> Response:
-        return self.get("{}/military/campaignsJson/list".format(self.url))
+        return self.get(f"{self.url}/military/campaignsJson/list")
 
     def _get_military_campaigns_json_citizen(self) -> Response:
-        return self.get("{}/military/campaignsJson/citizen".format(self.url))
+        return self.get(f"{self.url}/military/campaignsJson/citizen")
 
     def _get_military_unit_data(self, unit_id: int, **kwargs) -> Response:
         params = {"groupId": unit_id, "panel": "members", **kwargs}
-        return self.get("{}/military/military-unit-data/".format(self.url), params=params)
+        return self.get(f"{self.url}/military/military-unit-data/", params=params)
 
-    def _post_main_activate_battle_effect(self, battle: int, kind: str, citizen_id: int) -> Response:
+    def _post_main_activate_battle_effect(self, battle_id: int, kind: str, citizen_id: int) -> Response:
-        data = dict(battleId=battle, citizenId=citizen_id, type=kind, _token=self.token)
+        data = dict(battleId=battle_id, citizenId=citizen_id, type=kind, _token=self.token)
-        return self.post("{}/main/fight-activateBattleEffect".format(self.url), data=data)
+        return self.post(f"{self.url}/main/fight-activateBattleEffect", data=data)
 
     def _post_main_battlefield_travel(self, side_id: int, battle_id: int) -> Response:
         data = dict(_token=self.token, sideCountryId=side_id, battleId=battle_id)
-        return self.post("{}/main/battlefieldTravel".format(self.url), data=data)
+        return self.post(f"{self.url}/main/battlefieldTravel", data=data)
 
     def _post_main_battlefield_change_division(self, battle_id: int, division_id: int) -> Response:
         data = dict(_token=self.token, battleZoneId=division_id, battleId=battle_id)
-        return self.post("{}/main/battlefieldTravel".format(self.url), data=data)
+        return self.post(f"{self.url}/main/battlefieldTravel", data=data)
 
     def _get_wars_show(self, war_id: int) -> Response:
-        return self.get("{}/wars/show/{}".format(self.url, war_id))
+        return self.get(f"{self.url}/wars/show/{war_id}")
 
-    def _post_military_fight_activate_booster(self, battle: int, quality: int, duration: int, kind: str) -> Response:
+    def _post_military_fight_activate_booster(self, battle_id: int, quality: int, duration: int, kind: str) -> Response:
-        data = dict(type=kind, quality=quality, duration=duration, battleId=battle, _token=self.token)
+        data = dict(type=kind, quality=quality, duration=duration, battleId=battle_id, _token=self.token)
-        return self.post("{}/military/fight-activateBooster".format(self.url), data=data)
+        return self.post(f"{self.url}/military/fight-activateBooster", data=data)
 
-    def _post_military_change_weapon(self, battle: int, battle_zone: int, weapon_level: int, ) -> Response:
+    def _post_military_change_weapon(self, battle_id: int, battle_zone: int, weapon_level: int, ) -> Response:
-        data = dict(battleId=battle, _token=self.token, battleZoneId=battle_zone, customizationLevel=weapon_level)
+        data = dict(battleId=battle_id, _token=self.token, battleZoneId=battle_zone, customizationLevel=weapon_level)
-        return self.post("{}/military/change-weapon".format(self.url), data=data)
+        return self.post(f"{self.url}/military/change-weapon", data=data)
 
     def _post_military_battle_console(self, battle_id: int, action: str, page: int = 1, **kwargs) -> Response:
         data = dict(battleId=battle_id, action=action, _token=self.token)
@@ -417,19 +412,19 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
                         division=kwargs["division"], type=kwargs.get("type", 'damage'), )
         elif action == "warList":
             data.update(page=page)
-        return self.post("{}/military/battle-console".format(self.url), data=data)
+        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)
-        return self.post("{}/military/deploy-bomb".format(self.url), data=data)
+        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:
         data = dict(sideId=side_id, battleId=battle_id, _token=self.token, battleZoneId=zone_id)
-        return self.post("{}/military/fight-shoooot/{}".format(self.url, battle_id), data=data)
+        return self.post(f"{self.url}/military/fight-shoooot/{battle_id}", data=data)
 
     def _post_military_fight_ground(self, battle_id: int, side_id: int, zone_id: int) -> Response:
         data = dict(sideId=side_id, battleId=battle_id, _token=self.token, battleZoneId=zone_id)
-        return self.post("{}/military/fight-shooot/{}".format(self.url, battle_id), data=data)
+        return self.post(f"{self.url}/military/fight-shooot/{battle_id}", data=data)
 
     def _post_fight_deploy_deploy_report_data(self, deployment_id: int):
         data = dict(_token=self.token, deploymentId=deployment_id)
@@ -438,17 +433,17 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
 
 class ErepublikPoliticsAPI(CitizenBaseAPI):
     def _get_candidate_party(self, party_slug: str) -> Response:
-        return self.post("{}/candidate/{}".format(self.url, party_slug))
+        return self.post(f"{self.url}/candidate/{party_slug}")
 
-    def _get_main_party_members(self, party: int) -> Response:
+    def _get_main_party_members(self, party_id: int) -> Response:
-        return self.get("{}/main/party-members/{}".format(self.url, party))
+        return self.get(f"{self.url}/main/party-members/{party_id}")
 
-    def _get_main_rankings_parties(self, country: int) -> Response:
+    def _get_main_rankings_parties(self, country_id: int) -> Response:
-        return self.get("{}/main/rankings-parties/1/{}".format(self.url, country))
+        return self.get(f"{self.url}/main/rankings-parties/1/{country_id}")
 
     def _post_candidate_for_congress(self, presentation: str = "") -> Response:
         data = dict(_token=self.token, presentation=presentation)
-        return self.post("{}/candidate-for-congress".format(self.url), data=data)
+        return self.post(f"{self.url}/candidate-for-congress", data=data)
 
     def _get_presidential_elections(self, country_id: int, timestamp: int) -> Response:
         return self.get(f"{self.url}/main/presidential-elections/{country_id}/{timestamp}")
@@ -462,50 +457,50 @@ class ErepublikPresidentAPI(CitizenBaseAPI):
     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,
                     countryNameConfirm=constants.COUNTRIES[attack_country_id].link)
-        return self.post("{}/{}/new-war".format(self.url, constants.COUNTRIES[self_country_id].link), data=data)
+        return self.post(f"{self.url}/{constants.COUNTRIES[self_country_id].link}/new-war", data=data)
 
     def _post_new_donation(self, country_id: int, amount: int, org_name: str, debate: str = "") -> Response:
         data = dict(requirments=1, _token=self.token, debate=debate, currency=1, value=amount, commit='Propose',
                     type_name=org_name)
-        return self.post("{}/{}/new-donation".format(self.url, constants.COUNTRIES[country_id].link), data=data)
+        return self.post(f"{self.url}/{constants.COUNTRIES[country_id].link}/new-donation", data=data)
 
 
 class ErepublikProfileAPI(CitizenBaseAPI):
-    def _get_main_citizen_hovercard(self, citizen: int) -> Response:
+    def _get_main_citizen_hovercard(self, citizen_id: int) -> Response:
-        return self.get("{}/main/citizen-hovercard/{}".format(self.url, citizen))
+        return self.get(f"{self.url}/main/citizen-hovercard/{citizen_id}")
 
-    def _get_main_citizen_profile_json(self, player_id: int) -> Response:
+    def _get_main_citizen_profile_json(self, citizen_id: int) -> Response:
-        return self.get("{}/main/citizen-profile-json/{}".format(self.url, player_id))
+        return self.get(f"{self.url}/main/citizen-profile-json/{citizen_id}")
 
     def _get_main_citizen_notifications(self) -> Response:
-        return self.get("{}/main/citizenDailyAssistant".format(self.url))
+        return self.get(f"{self.url}/main/citizenDailyAssistant")
 
     def _get_main_citizen_daily_assistant(self) -> Response:
-        return self.get("{}/main/citizenNotifications".format(self.url))
+        return self.get(f"{self.url}/main/citizenNotifications")
 
     def _get_main_messages_paginated(self, page: int = 1) -> Response:
-        return self.get("{}/main/messages-paginated/{}".format(self.url, page))
+        return self.get(f"{self.url}/main/messages-paginated/{page}")
 
     def _get_main_money_donation_accept(self, donation_id: int) -> Response:
-        return self.get("{}/main/money-donation/accept/{}".format(self.url, donation_id), params={"_token": self.token})
+        return self.get(f"{self.url}/main/money-donation/accept/{donation_id}", params={"_token": self.token})
 
     def _get_main_money_donation_reject(self, donation_id: int) -> Response:
-        return self.get("{}/main/money-donation/reject/{}".format(self.url, donation_id), params={"_token": self.token})
+        return self.get(f"{self.url}/main/money-donation/reject/{donation_id}", params={"_token": self.token})
 
     def _get_main_notifications_ajax_community(self, page: int = 1) -> Response:
-        return self.get("{}/main/notificationsAjax/community/{}".format(self.url, page))
+        return self.get(f"{self.url}/main/notificationsAjax/community/{page}")
 
     def _get_main_notifications_ajax_system(self, page: int = 1) -> Response:
-        return self.get("{}/main/notificationsAjax/system/{}".format(self.url, page))
+        return self.get(f"{self.url}/main/notificationsAjax/system/{page}")
 
     def _get_main_notifications_ajax_report(self, page: int = 1) -> Response:
-        return self.get("{}/main/notificationsAjax/report/{}".format(self.url, page))
+        return self.get(f"{self.url}/main/notificationsAjax/report/{page}")
 
     def _get_main_training_grounds_json(self) -> Response:
-        return self.get("{}/main/training-grounds-json".format(self.url))
+        return self.get(f"{self.url}/main/training-grounds-json")
 
     def _get_main_weekly_challenge_data(self) -> Response:
-        return self.get("{}/main/weekly-challenge-data".format(self.url))
+        return self.get(f"{self.url}/main/weekly-challenge-data")
 
     def _post_main_citizen_add_remove_friend(self, citizen: int, add: bool) -> Response:
         data = dict(_token=self.token, citizenId=citizen, url="//www.erepublik.com/en/main/citizen-addRemoveFriend")
@@ -513,60 +508,60 @@ class ErepublikProfileAPI(CitizenBaseAPI):
             data.update({"action": "addFriend"})
         else:
             data.update({"action": "removeFriend"})
-        return self.post("{}/main/citizen-addRemoveFriend".format(self.url), data=data)
+        return self.post(f"{self.url}/main/citizen-addRemoveFriend", data=data)
 
     def _post_main_daily_task_reward(self) -> Response:
-        return self.post("{}/main/daily-tasks-reward".format(self.url), data=dict(_token=self.token))
+        return self.post(f"{self.url}/main/daily-tasks-reward", data=dict(_token=self.token))
 
     def _post_delete_message(self, msg_id: list) -> Response:
         data = {"_token": self.token, "delete_message[]": msg_id}
-        return self.post("{}/main/messages-delete".format(self.url), data)
+        return self.post(f"{self.url}/main/messages-delete", data)
 
     def _post_eat(self, color: str) -> Response:
         data = dict(_token=self.token, buttonColor=color)
-        return self.post("{}/main/eat".format(self.url), params=data)
+        return self.post(f"{self.url}/main/eat", params=data)
 
     def _post_main_global_alerts_close(self, alert_id: int) -> Response:
         data = dict(_token=self.token, alert_id=alert_id)
-        return self.post("{}/main/global-alerts/close".format(self.url), data=data)
+        return self.post(f"{self.url}/main/global-alerts/close", data=data)
 
     def _post_forgot_password(self, email: str) -> Response:
         data = dict(_token=self.token, email=email, commit="Reset password")
-        return self.post("{}/forgot-password".format(self.url), data=data)
+        return self.post(f"{self.url}/forgot-password", data=data)
 
     def _post_login(self, email: str, password: str) -> Response:
         data = dict(csrf_token=self.token, citizen_email=email, citizen_password=password, remember='on')
-        return self.post("{}/login".format(self.url), data=data)
+        return self.post(f"{self.url}/login", data=data)
 
     def _post_main_messages_alert(self, notification_ids: List[int]) -> Response:
         data = {"_token": self.token, "delete_alerts[]": notification_ids, "deleteAllAlerts": "1", "delete": "Delete"}
-        return self.post("{}/main/messages-alerts/1".format(self.url), data=data)
+        return self.post(f"{self.url}/main/messages-alerts/1", data=data)
 
     def _post_main_notifications_ajax_community(self, notification_ids: List[int], page: int = 1) -> Response:
         data = {"_token": self.token, "delete_alerts[]": notification_ids}
-        return self.post("{}/main/notificationsAjax/community/{}".format(self.url, page), data=data)
+        return self.post(f"{self.url}/main/notificationsAjax/community/{page}", data=data)
 
     def _post_main_notifications_ajax_system(self, notification_ids: List[int], page: int = 1) -> Response:
         data = {"_token": self.token, "delete_alerts[]": notification_ids}
-        return self.post("{}/main/notificationsAjax/system/{}".format(self.url, page), data=data)
+        return self.post(f"{self.url}/main/notificationsAjax/system/{page}", data=data)
 
     def _post_main_notifications_ajax_report(self, notification_ids: List[int], page: int = 1) -> Response:
         data = {"_token": self.token, "delete_alerts[]": notification_ids}
-        return self.post("{}/main/notificationsAjax/report/{}".format(self.url, page), data=data)
+        return self.post(f"{self.url}/main/notificationsAjax/report/{page}", data=data)
 
     def _post_main_messages_compose(self, subject: str, body: str, citizens: List[int]) -> Response:
         url_pk = 0 if len(citizens) > 1 else str(citizens[0])
         data = dict(citizen_name=",".join([str(x) for x in citizens]),
                     citizen_subject=subject, _token=self.token, citizen_message=body)
-        return self.post("{}/main/messages-compose/{}".format(self.url, url_pk), data=data)
+        return self.post(f"{self.url}/main/messages-compose/{url_pk}", data=data)
 
     def _post_military_group_missions(self) -> Response:
         data = dict(action="check", _token=self.token)
-        return self.post("{}/military/group-missions".format(self.url), data=data)
+        return self.post(f"{self.url}/military/group-missions", data=data)
 
     def _post_main_weekly_challenge_reward(self, reward_id: int) -> Response:
         data = dict(_token=self.token, rewardId=reward_id)
-        return self.post("{}/main/weekly-challenge-collect-reward".format(self.url), data=data)
+        return self.post(f"{self.url}/main/weekly-challenge-collect-reward", data=data)
 
     def _post_main_profile_update(self, action: str, params: str):
         data = {"action": action, "params": params, "_token": self.token}
@@ -576,10 +571,10 @@ class ErepublikProfileAPI(CitizenBaseAPI):
 class ErepublikTravelAPI(CitizenBaseAPI):
     def _post_main_travel(self, check: str, **kwargs) -> Response:
         data = dict(_token=self.token, check=check, **kwargs)
-        return self.post("{}/main/travel".format(self.url), data=data)
+        return self.post(f"{self.url}/main/travel", data=data)
 
     def _post_main_travel_data(self, **kwargs) -> Response:
-        return self.post("{}/main/travelData".format(self.url), data=dict(_token=self.token, **kwargs))
+        return self.post(f"{self.url}/main/travelData", data=dict(_token=self.token, **kwargs))
 
 
 class ErepublikWallPostAPI(CitizenBaseAPI):
@@ -587,78 +582,78 @@ class ErepublikWallPostAPI(CitizenBaseAPI):
 
     def _post_main_country_comment_retrieve(self, post_id: int) -> Response:
         data = {"_token": self.token, "postId": post_id}
-        return self.post("{}/main/country-comment/retrieve/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/country-comment/retrieve/json", data=data)
 
     def _post_main_country_comment_create(self, post_id: int, comment_message: str) -> Response:
         data = {"_token": self.token, "postId": post_id, 'comment_message': comment_message}
-        return self.post("{}/main/country-comment/create/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/country-comment/create/json", data=data)
 
     def _post_main_country_post_create(self, body: str, post_as: int) -> Response:
         data = {"_token": self.token, "post_message": body, "post_as": post_as}
-        return self.post("{}/main/country-post/create/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/country-post/create/json", data=data)
 
     def _post_main_country_post_retrieve(self) -> Response:
         data = {"_token": self.token, "page": 1, "switchedFrom": False}
-        return self.post("{}/main/country-post/retrieve/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/country-post/retrieve/json", data=data)
 
     # ## Military Unit
 
     def _post_main_military_unit_comment_retrieve(self, post_id: int) -> Response:
         data = {"_token": self.token, "postId": post_id}
-        return self.post("{}/main/military-unit-comment/retrieve/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/military-unit-comment/retrieve/json", data=data)
 
     def _post_main_military_unit_comment_create(self, post_id: int, comment_message: str) -> Response:
         data = {"_token": self.token, "postId": post_id, 'comment_message': comment_message}
-        return self.post("{}/main/military-unit-comment/create/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/military-unit-comment/create/json", data=data)
 
     def _post_main_military_unit_post_create(self, body: str, post_as: int) -> Response:
         data = {"_token": self.token, "post_message": body, "post_as": post_as}
-        return self.post("{}/main/military-unit-post/create/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/military-unit-post/create/json", data=data)
 
     def _post_main_military_unit_post_retrieve(self) -> Response:
         data = {"_token": self.token, "page": 1, "switchedFrom": False}
-        return self.post("{}/main/military-unit-post/retrieve/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/military-unit-post/retrieve/json", data=data)
 
     # ## Party
 
     def _post_main_party_comment_retrieve(self, post_id: int) -> Response:
         data = {"_token": self.token, "postId": post_id}
-        return self.post("{}/main/party-comment/retrieve/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/party-comment/retrieve/json", data=data)
 
     def _post_main_party_comment_create(self, post_id: int, comment_message: str) -> Response:
         data = {"_token": self.token, "postId": post_id, 'comment_message': comment_message}
-        return self.post("{}/main/party-comment/create/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/party-comment/create/json", data=data)
 
     def _post_main_party_post_create(self, body: str) -> Response:
         data = {"_token": self.token, "post_message": body}
-        return self.post("{}/main/party-post/create/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/party-post/create/json", data=data)
 
     def _post_main_party_post_retrieve(self) -> Response:
         data = {"_token": self.token, "page": 1, "switchedFrom": False}
-        return self.post("{}/main/party-post/retrieve/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/party-post/retrieve/json", data=data)
 
     # ## Friend's Wall
 
     def _post_main_wall_comment_retrieve(self, post_id: int) -> Response:
         data = {"_token": self.token, "postId": post_id}
-        return self.post("{}/main/wall-comment/retrieve/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/wall-comment/retrieve/json", data=data)
 
     def _post_main_wall_comment_create(self, post_id: int, comment_message: str) -> Response:
         data = {"_token": self.token, "postId": post_id, 'comment_message': comment_message}
-        return self.post("{}/main/wall-comment/create/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/wall-comment/create/json", data=data)
 
     def _post_main_wall_post_create(self, body: str) -> Response:
         data = {"_token": self.token, "post_message": body}
-        return self.post("{}/main/wall-post/create/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/wall-post/create/json", data=data)
 
     def _post_main_wall_post_retrieve(self) -> Response:
         data = {"_token": self.token, "page": 1, "switchedFrom": False}
-        return self.post("{}/main/wall-post/retrieve/json".format(self.url), data=data)
+        return self.post(f"{self.url}/main/wall-post/retrieve/json", data=data)
 
     # ## Medal posting
     def _post_main_wall_post_automatic(self, message: str, achievement_id: int) -> Response:
-        return self.post("{}/main/wall-post/automatic".format(self.url), data=dict(_token=self.token, message=message,
+        return self.post(f"{self.url}/main/wall-post/automatic", data=dict(_token=self.token, message=message,
-                                                                                   achievementId=achievement_id))
+                                                                           achievementId=achievement_id))
 
 
 class CitizenAPI(

erepublik/citizen.py

@@ -695,6 +695,17 @@ class CitizenTravel(BaseCitizen):
         self.details.current_region = region_id
         self.details.current_country = country
 
+    def _travel(self, country: constants.Country, region_id: int = 0) -> bool:
+        r_json = super()._travel(country, region_id).json()
+        if not bool(r_json.get('error')):
+            self._update_citizen_location(country, region_id)
+            return True
+        else:
+            if "Travelling too fast." in r_json.get('message'):
+                self.sleep(1)
+                return self._travel(country, region_id)
+        return False
+
     def get_country_travel_region(self, country: constants.Country) -> int:
         regions = self.get_travel_regions(country=country)
         regs = []
@@ -711,12 +722,12 @@ class CitizenTravel(BaseCitizen):
         self.update_citizen_info()
         res_r = self.details.residence_region
         if self.details.residence_country and res_r and not res_r == self.details.current_region:
-            r_json = self._travel(self.details.residence_country, self.details.residence_region).json()
+            if self._travel(self.details.residence_country, self.details.residence_region):
-            if r_json.get('message', '') == 'success':
+                self._report_action("TRAVEL", "Traveled to residence")
-                self._update_citizen_location(self.details.residence_country, self.details.current_region)
-                self._report_action("TRAVEL", "Traveled to residence", response=r_json)
                 return True
-            return False
+            else:
+                self._report_action("TRAVEL", "Unable to travel to residence!")
+                return False
         return True
 
     def travel_to_region(self, region_id: int) -> bool:
@@ -725,12 +736,14 @@ class CitizenTravel(BaseCitizen):
             return True
         else:
             country = constants.COUNTRIES[data.get('preselectCountryId')]
-            r_json = self._travel(country, region_id).json()
+
-            if r_json.get('message', '') == 'success':
+            if self._travel(country, region_id):
-                self._update_citizen_location(country, region_id)
+                self._report_action("TRAVEL", "Traveled to region")
-                self._report_action("TRAVEL", "Traveled to region", response=r_json)
                 return True
-            return False
+            else:
+                self._report_action("TRAVEL", "Unable to travel to region!")
+
+        return False
 
     def travel_to_country(self, country: constants.Country) -> bool:
         data = self._post_main_travel_data(countryId=country.id, check="getCountryRegions").json()
@@ -742,11 +755,13 @@ class CitizenTravel(BaseCitizen):
                     regs.append((region['id'], region['distanceInKm']))
         if regs:
             region_id = min(regs, key=lambda _: int(_[1]))[0]
-            r_json = self._travel(country, region_id).json()
+
-            if r_json.get('message', '') == 'success':
+            if self._travel(country, region_id):
-                self._update_citizen_location(country, region_id)
+                self._report_action("TRAVEL", f"Traveled to {country.name}")
-                self._report_action("TRAVEL", f"Traveled to {country.name}", response=r_json)
                 return True
+            else:
+                self._report_action("TRAVEL", f"Unable to travel to {country.name}!")
+
         return False
 
     def travel_to_holding(self, holding: classes.Holding) -> bool:
@@ -756,15 +771,36 @@ class CitizenTravel(BaseCitizen):
         else:
             country = constants.COUNTRIES[data.get('preselectCountryId')]
             region_id = data.get('preselectRegionId')
-            r_json = self._travel(country, region_id).json()
-            if r_json.get('message', '') == 'success':
-                self._update_citizen_location(country, region_id)
-                self._report_action("TRAVEL", f"Traveled to holding {holding}", response=r_json)
-                return True
-            return False
 
-    def get_travel_regions(self, holding: classes.Holding = None, battle: classes.Battle = None, country: constants.Country = None
+            if self._travel(country, region_id):
-                           ) -> Union[List[Any], Dict[str, Dict[str, Any]]]:
+                self._report_action("TRAVEL", f"Traveled to {holding}")
+                return True
+            else:
+                self._report_action("TRAVEL", f"Unable to travel to {holding}!")
+
+    def travel_to_battle(self, battle: classes.Battle, allowed_countries: List[constants.Country]) -> bool:
+        data = self.get_travel_regions(battle=battle)
+
+        regs = []
+        countries: Dict[int, constants.Country] = {c.id: c for c in allowed_countries}
+        if data:
+            for region in data.values():
+                if region['countryId'] in countries:  # Is not occupied by other country
+                    regs.append((region['distanceInKm'], region['id'], countries[region['countryId']]))
+        if regs:
+            reg = min(regs, key=lambda _: int(_[0]))
+            region_id = reg[1]
+            country = reg[2]
+            if self._travel(country, region_id):
+                self._report_action("TRAVEL", f"Traveled to {battle}")
+                return True
+            else:
+                self._report_action("TRAVEL", f"Unable to travel to {battle}!")
+        return False
+
+    def get_travel_regions(
+        self, holding: classes.Holding = None, battle: classes.Battle = None, country: constants.Country = None
+    ) -> Union[List[Any], Dict[str, Dict[str, Any]]]:
         return self._post_main_travel_data(
             holdingId=holding.id if holding else 0,
             battleId=battle.id if battle else 0,
@@ -855,11 +891,7 @@ class CitizenCompanies(BaseCitizen):
 
                             Storage={1000: 1, 2000: 2} <- Building_type 2
         """
-        company_name = {1: "Food", 2: "Weapons", 4: "House", 23: "Aircraft",
+        company_name = constants.INDUSTRIES[industry_id]
-                        7: "FRM q1", 8: "FRM q2", 9: "FRM q3", 10: "FRM q4", 11: "FRM q5",
-                        12: "WRM q1", 13: "WRM q2", 14: "WRM q3", 15: "WRM q4", 16: "WRM q5",
-                        18: "HRM q1", 19: "HRM q2", 20: "HRM q3", 21: "HRM q4", 22: "HRM q5",
-                        24: "ARM q1", 25: "ARM q2", 26: "ARM q3", 27: "ARM q4", 28: "ARM q5", }[industry_id]
         if building_type == 2:
             company_name = "Storage"
         self.write_log(f'{company_name} created!')
@@ -984,7 +1016,7 @@ class CitizenEconomy(CitizenTravel):
             self.write_log(f"Trying to sell unsupported industry {industry}")
 
         data = {
-            "country": self.details.citizenship,
+            "country_id": self.details.citizenship,
             "industry": industry,
             "quality": quality,
             "amount": amount,
@@ -1165,9 +1197,9 @@ class CitizenEconomy(CitizenTravel):
         if self.details.cc < amount or amount < 20:
             return False
         data = dict(country=country.id, action='currency', value=amount)
-        r = self._post_main_country_donate(**data)
+        r = self._post_main_country_donate(country.id, 'currency', amount)
         if r.json().get('status') or not r.json().get('error'):
-            self._report_action("CONTRIBUTE_CC", f'Contributed {amount}cc to {country}\'s treasury')
+            self._report_action("CONTRIBUTE_CC", f'Contributed {amount}cc to {country}\'s treasury', kwargs=data)
             return True
         else:
             self._report_action("CONTRIBUTE_CC", f"Unable to contribute {amount}cc to {country}'s"
@@ -1180,11 +1212,11 @@ class CitizenEconomy(CitizenTravel):
         if self.food["q" + str(quality)] < amount or amount < 10:
             return False
         data = dict(country=country.id, action='food', value=amount, quality=quality)
-        r = self._post_main_country_donate(**data)
+        r = self._post_main_country_donate(country.id, 'currency', amount, quality)
 
         if r.json().get('status') or not r.json().get('error'):
             self._report_action("CONTRIBUTE_FOOD", f"Contributed {amount}q{quality} food to "
-                                                   f"{country}'s treasury")
+                                                   f"{country}'s treasury", kwargs=data)
             return True
         else:
             self._report_action("CONTRIBUTE_FOOD", f"Unable to contribute {amount}q{quality} food to "
@@ -1197,11 +1229,10 @@ class CitizenEconomy(CitizenTravel):
         if self.details.cc < amount:
             return False
         data = dict(country=country.id, action='gold', value=amount)
-        self.reporter.report_action("CONTRIBUTE_GOLD", data, str(amount))
+        r = self._post_main_country_donate(country.id, 'gold', amount)
-        r = self._post_main_country_donate(**data)
 
         if r.json().get('status') or not r.json().get('error'):
-            self._report_action("CONTRIBUTE_GOLD", f"Contributed {amount}g to {country}'s treasury")
+            self._report_action("CONTRIBUTE_GOLD", f"Contributed {amount}g to {country}'s treasury", kwargs=data)
             return True
         else:
             self._report_action("CONTRIBUTE_GOLD", f"Unable to contribute {amount}g to {country}'s"
@@ -1260,8 +1291,8 @@ class CitizenMedia(BaseCitizen):
                  4: "Political debates and analysis", 5: "Financial business",
                  6: "Social interactions and entertainment"}
         if kind in kinds:
-            data = {'title': title, 'content': content, 'country': self.details.citizenship, 'kind': kind}
+            data = {'title': title, 'content': content, 'country': self.details.citizenship.id, 'kind': kind}
-            resp = self._post_main_write_article(**data)
+            resp = self._post_main_write_article(title, content, self.details.citizenship.id, kind)
             try:
                 article_id = int(resp.history[1].url.split("/")[-3])
                 self._report_action("ARTICLE_PUBLISH", f"Published new article \"{title}\" ({article_id})", kwargs=data)
@@ -1869,9 +1900,9 @@ class CitizenMilitary(CitizenTravel):
     def get_battle_round_data(self, division: classes.BattleDivision) -> Tuple[Any, Any]:
         battle = division.battle
 
-        data = dict(zoneId=battle.zone_id, round_id=battle.zone_id, division=division.div,
+        r = self._post_military_battle_console(battle.id, "battleStatistics", 1,
-                    battleZoneId=division.id, type="damage")
+                                               zoneId=battle.zone_id, round_id=battle.zone_id, division=division.div,
-        r = self._post_military_battle_console(battle.id, "battleStatistics", 1, **data)
+                                               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"))
@@ -1899,25 +1930,6 @@ class CitizenMilitary(CitizenTravel):
         self._post_wars_attack_region(war_id, region_id, region_name)
         self._report_action("MILITARY_QUEUE_ATTACK", f"Battle for *{region_name}* queued")
 
-    def travel_to_battle(self, battle: classes.Battle, allowed_countries: List[constants.Country]) -> bool:
-        data = self.get_travel_regions(battle=battle)
-
-        regs = []
-        countries: Dict[int, constants.Country] = {c.id: c for c in allowed_countries}
-        if data:
-            for region in data.values():
-                if region['countryId'] in countries:  # Is not occupied by other country
-                    regs.append((region['distanceInKm'], region['id'], countries[region['countryId']]))
-        if regs:
-            reg = min(regs, key=lambda _: int(_[0]))
-            region_id = reg[1]
-            country = reg[2]
-            r = self._travel(country, region_id).json()
-            if r.get('message', '') == 'success':
-                self._update_citizen_location(country, region_id)
-                return True
-        return False
-
     def get_country_mus(self, country: constants.Country) -> Dict[int, str]:
         ret = {}
         r = self._get_main_leaderboards_damage_rankings(country.id)
@@ -1948,9 +1960,8 @@ class CitizenMilitary(CitizenTravel):
         mu_id = profile.get('military', {}).get('militaryUnit', {}).get('id', 0)
         if mu_id:
             name = profile.get('citizen', {}).get('name')
-            params = dict(currentPage=1, panel="members", sortBy="dailyOrdersCompleted",
+            member = self._get_military_unit_data(mu_id, currentPage=1, panel="members", sortBy="dailyOrdersCompleted",
-                          weekFilter=f"week{weeks_ago}", search=name)
+                                                  weekFilter=f"week{weeks_ago}", search=name).json()
-            member = self._get_military_unit_data(mu_id, **params).json()
             return member.get('panelContents', {}).get('members', [{}])[0].get('dailyOrdersCompleted')
         return 0
 
@@ -2199,20 +2210,19 @@ class CitizenTasks(BaseCitizen):
         self._report_action('ECONOMY_TG_CONTRACT', 'Bought TG Contract', kwargs=extra)
         return ret
 
-    def find_new_job(self) -> Response:
+    def find_new_job(self) -> bool:
         r = self._get_economy_job_market_json(self.details.current_country.id)
         jobs = r.json().get("jobs")
-        data = dict(citizen=0, salary=10)
+        data = dict(citizen_id=0, salary=10)
         for posting in jobs:
             salary = posting.get("salary")
             limit = posting.get("salaryLimit", 0)
             citizen_id = posting.get("citizen").get("id")
 
             if (not limit or salary * 3 < limit) and salary > data["salary"]:
-                data.update({"citizen": citizen_id, "salary": salary})
+                data.update(citizen_id=citizen_id, salary=salary)
 
-        self._report_action("ECONOMY_APPLY_FOR_JOB", f"I'm working now for {str(data['citizen'])}", kwargs=r.json())
+        return self.apply_to_employer(data['citizen_id'], data['salary'])
-        return self._post_economy_job_market_apply(**data)
 
     def apply_to_employer(self, employer_id: int, salary: float) -> bool:
         data = dict(citizenId=employer_id, salary=salary)

erepublik/constants.py

@@ -19,6 +19,9 @@ class Country:
         self.link = link
         self.iso = iso
 
+    def __hash__(self):
+        return hash((self.id, self.name))
+
     def __repr__(self):
         return f"Country({self.id}, '{self.name}', '{self.link}', '{self.iso}')"
 
@@ -47,7 +50,7 @@ class Country:
 
 class Industries:
     __by_name = {'food': 1, 'weapons': 2, 'house': 4, 'aircraft': 23,
-                 'foodRaw': 7, 'weaponRaw': 12, 'weaponsRaw': 12, 'houseRaw': 18, 'aircraftRaw': 24,
+                 'foodraw': 7, 'weaponraw': 12, 'weaponsraw': 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,

erepublik/utils.py

@@ -1,3 +1,4 @@
+import copy
 import datetime
 import inspect
 import os
@@ -9,7 +10,7 @@ import traceback
 import unicodedata
 from decimal import Decimal
 from pathlib import Path
-from typing import Any, List, Mapping, Optional, Union
+from typing import Any, List, Mapping, Optional, Union, Dict
 
 import requests
 
@@ -177,7 +178,7 @@ def write_request(response: requests.Response, is_error: bool = False):
                 "mimetype": "application/json" if ext == "json" else "text/html"}
 
 
-def send_email(name: str, content: List[Any], player=None, local_vars: Mapping[Any, Any] = None,
+def send_email(name: str, content: List[Any], player=None, local_vars: Dict[str, Any] = None,
                promo: bool = False, captcha: bool = False):
     if local_vars is None:
         local_vars = {}
@@ -220,6 +221,14 @@ def send_email(name: str, content: List[Any], player=None, local_vars: Mapping[A
     if local_vars:
         if "state_thread" in local_vars:
             local_vars.pop('state_thread', None)
+
+        if isinstance(local_vars.get('self'), Citizen):
+            local_vars['self'] = repr(local_vars['self'])
+        if isinstance(local_vars.get('player'), Citizen):
+            local_vars['player'] = repr(local_vars['player'])
+        if isinstance(local_vars.get('citizen'), Citizen):
+            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),
                                "application/json")))

requirements_dev.txt

@@ -1,17 +1,17 @@
 bump2version==1.0.0
-coverage==5.1
+coverage==5.2
 edx-sphinx-theme==1.5.0
 flake8==3.8.3
-ipython==7.15.0
+ipython==7.16.1
-isort==4.3.21
+isort==5.0.9
 pip==20.1.1
 PyInstaller==3.6
 pytz==2020.1
-requests==2.23.0
+pytest==5.4.3
 responses==0.10.15
-setuptools==47.1.1
+setuptools==49.2.0
-Sphinx==3.1.1
+Sphinx==3.1.2
-tox==3.15.2
+tox==3.16.1
-twine==3.1.1
+twine==3.2.0
-watchdog==0.10.2
+watchdog==0.10.3
 wheel==0.34.2

setup.cfg

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

setup.py

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