Bump version: 0.21.0.3 → 0.21.1

Update traveling to incorporate travel cooldown (1travel / 15sec)
Change variable names to be more precise if argument must be and id or instance (battle/battle_id, division/division_id)
2020-07-16 11:15:04 +03:00 · 2020-07-16 11:14:35 +03:00 · 2020-07-16 11:13:29 +03:00 · 2020-07-16 11:11:35 +03:00 · 2020-07-16 11:08:31 +03:00 · 2020-07-14 15:37:59 +03:00
11 changed files with 706 additions and 649 deletions
--- a/README.rst
+++ b/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
+
--- a/erepublik/init.py
+++ b/erepublik/init.py
@ -4,10 +4,9 @@

 __author__ = """Eriks Karls"""
 __email__ = 'eriks@72.lv'
-__version__ = '0.20.3.4'
-__commit_id__ = "8ce56a3"
+__version__ = '0.21.1'

-from erepublik import classes, utils
+from erepublik import classes, utils, constants
 from erepublik.citizen import Citizen

-__all__ = ["classes", "utils", "Citizen"]
+__all__ = ["classes", "utils", "Citizen", ]
--- a/erepublik/access_points.py
+++ b/erepublik/access_points.py
@ -5,7 +5,7 @@ from typing import Any, Dict, List, Mapping, Union

 from requests import Response, Session

-from erepublik import utils
+from . import constants, utils

 __all__ = ['SlowRequests', 'CitizenAPI']

@ -45,7 +45,7 @@ class SlowRequests(Session):
        })

    @property
-    def __dict__(self):
+    def as_dict(self):
        return dict(last_time=self.last_time, timeout=self.timeout, user_agent=self.headers['User-Agent'],
                    request_log_name=self.request_log_name, debug=self.debug)

@ -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:
-        data = dict(_token=self.token, articleId=article, page=page)
+    def _post_main_article_comments(self, article_id: int, page: int = 1) -> Response:
+        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:
-        data = dict(_token=self.token, message=message, articleId=article)
+    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_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:
-        data = dict(_token=self.token, article_name=title, article_body=content, article_location=country,
-                    article_category=kind)
-        return self.post("{}/main/write-article".format(self.url), data=data)
+    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_id,
+                    article_category=kind_id)
+        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:
-        data = dict(_token=self.token, factoryId=factory, action="assign", holdingCompanyId=holding)
-        return self.post("{}/economy/assign-to-holding".format(self.url), data=data)
+    def _post_economy_assign_to_holding(self, factory_id: int, holding_id: int) -> Response:
+        data = dict(_token=self.token, factoryId=factory_id, action="assign", holdingCompanyId=holding_id)
+        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:
-        data = {"_token": self.token, "company[industry_id]": industry, "company[building_type]": building_type}
-        return self.post("{}/economy/create-company".format(self.url), data=data,
-                         headers={"Referer": "{}/economy/create-company".format(self.url)})
+    def _post_economy_create_company(self, industry_id: int, building_type: int = 1) -> Response:
+        data = {"_token": self.token, "company[industry_id]": industry_id, "company[building_type]": building_type}
+        return self.post(f"{self.url}/economy/create-company", data=data,
+                         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:
-        return self.get("{}/economy/job-market-json/{}/1/desc".format(self.url, country))
+    def _get_economy_job_market_json(self, country_id: int) -> Response:
+        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:
-        data = dict(_token=self.token, citizenId=citizen, salary=salary)
-        return self.post("{}/economy/job-market-apply".format(self.url), data=data)
+    def _post_economy_job_market_apply(self, citizen_id: int, salary: float) -> Response:
+        data = dict(_token=self.token, citizenId=citizen_id, salary=salary)
+        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})
-        return self.post("{}/economy/sell-company/{}".format(self.url, factory),
+            data.update({"dissolve": factory_id})
+        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:
-        return self.get("{}/country/military/{}".format(self.url, country))
+    def _get_country_military(self, country_name: str) -> Response:
+        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,
-                         headers={"Referer": "{}/country/economy/Latvia".format(self.url)})
+
+        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"})


 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)
-        return self.post("{}/economy/donate-items-action".format(self.url), data=data,
-                         headers={"Referer": "{}/economy/donate-items/{}".format(self.url, citizen)})
+        data = dict(citizen_id=citizen_id, amount=amount, industry_id=industry, quality=quality, _token=self.token)
+        return self.post(f"{self.url}/economy/donate-items-action", data=data,
+                         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)
-        return self.post("{}/economy/donate-money-action".format(self.url), data=data,
-                         headers={"Referer": "{}/economy/donate-money/{}".format(self.url, citizen)})
+        data = dict(citizen_id=citizen_id, _token=self.token, currency_id=currency, amount=amount)
+        return self.post(f"{self.url}/economy/donate-money-action", data=data,
+                         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:
-        data = (country, weeks, mu)
-        return self.get("{}/main/leaderboards-damage-aircraft-rankings/{}/{}/{}/0".format(self.url, *data))
+    def _get_main_leaderboards_damage_aircraft_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0) -> Response:
+        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: int, weeks: int = 0, mu: int = 0,
-                                               div: int = 0) -> Response:
-        data = (country, weeks, mu, div)
-        return self.get("{}/main/leaderboards-damage-rankings/{}/{}/{}/{}".format(self.url, *data))
+    def _get_main_leaderboards_damage_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0, div: int = 0) -> Response:
+        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: int, weeks: int = 0, mu: int = 0) -> Response:
-        data = (country, weeks, mu)
-        return self.get("{}/main/leaderboards-kills-aircraft-rankings/{}/{}/{}/0".format(self.url, *data))
+    def _get_main_leaderboards_kills_aircraft_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0) -> Response:
+        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: int, weeks: int = 0, mu: int = 0,
-                                              div: int = 0) -> Response:
-        data = (country, weeks, mu, div)
-        return self.get("{}/main/leaderboards-kills-rankings/{}/{}/{}/{}".format(self.url, *data))
+    def _get_main_leaderboards_kills_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0, div: int = 0) -> Response:
+        return self.get(f"{self.url}/main/leaderboards-kills-rankings/{country_id}/{weeks}/{mu_id}/{div}")


 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:
-        return self.get("{}/military/battlefield-choose-side/{}/{}".format(self.url, battle, side))
+    def _get_military_battlefield_choose_side(self, battle_id: int, side_id: int) -> Response:
+        return self.get(f"{self.url}/military/battlefield-choose-side/{battle_id}/{side_id}")

-    def _get_military_show_weapons(self, battle: int) -> Response:
-        return self.get("{}/military/show-weapons".format(self.url), params={'_token': self.token, 'battleId': battle})
+    def _get_military_show_weapons(self, battle_id: int) -> Response:
+        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:
-        data = dict(battleId=battle, citizenId=citizen_id, type=kind, _token=self.token)
-        return self.post("{}/main/fight-activateBattleEffect".format(self.url), data=data)
+    def _post_main_activate_battle_effect(self, battle_id: int, kind: str, citizen_id: int) -> Response:
+        data = dict(battleId=battle_id, citizenId=citizen_id, type=kind, _token=self.token)
+        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:
-        data = dict(type=kind, quality=quality, duration=duration, battleId=battle, _token=self.token)
-        return self.post("{}/military/fight-activateBooster".format(self.url), data=data)
+    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_id, _token=self.token)
+        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:
-        data = dict(battleId=battle, _token=self.token, battleZoneId=battle_zone, customizationLevel=weapon_level)
-        return self.post("{}/military/change-weapon".format(self.url), data=data)
+    def _post_military_change_weapon(self, battle_id: int, battle_zone: int, weapon_level: int, ) -> Response:
+        data = dict(battleId=battle_id, _token=self.token, battleZoneId=battle_zone, customizationLevel=weapon_level)
+        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:
-        return self.get("{}/main/party-members/{}".format(self.url, party))
+    def _get_main_party_members(self, party_id: int) -> Response:
+        return self.get(f"{self.url}/main/party-members/{party_id}")

-    def _get_main_rankings_parties(self, country: int) -> Response:
-        return self.get("{}/main/rankings-parties/1/{}".format(self.url, country))
+    def _get_main_rankings_parties(self, country_id: int) -> Response:
+        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}")
@ -461,51 +456,51 @@ 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=utils.COUNTRY_LINK[attack_country_id])
-        return self.post("{}/{}/new-war".format(self.url, utils.COUNTRY_LINK[self_country_id]), data=data)
+                    countryNameConfirm=constants.COUNTRIES[attack_country_id].link)
+        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, utils.COUNTRY_LINK[country_id]), 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:
-        return self.get("{}/main/citizen-hovercard/{}".format(self.url, citizen))
+    def _get_main_citizen_hovercard(self, citizen_id: int) -> Response:
+        return self.get(f"{self.url}/main/citizen-hovercard/{citizen_id}")

-    def _get_main_citizen_profile_json(self, player_id: int) -> Response:
-        return self.get("{}/main/citizen-profile-json/{}".format(self.url, player_id))
+    def _get_main_citizen_profile_json(self, citizen_id: int) -> Response:
+        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,
-                                                                                   achievementId=achievement_id))
+        return self.post(f"{self.url}/main/wall-post/automatic", data=dict(_token=self.token, message=message,
+                                                                           achievementId=achievement_id))


 class CitizenAPI(
--- a/erepublik/citizen.py
+++ b/erepublik/citizen.py
--- a/erepublik/classes.py
+++ b/erepublik/classes.py
@ -6,52 +6,10 @@ from typing import Any, Dict, List, NamedTuple, Optional, Tuple, Union

 from requests import Response, Session, post

-from erepublik import utils
-from erepublik.utils import json
+from . import utils, constants

-INDUSTRIES = {1: "Food", 2: "Weapons", 4: "House", 23: "Aircraft",
-              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", }
-
-
-class Country:
-    id: int
-    name: str
-    link: str
-    iso: str
-
-    def __init__(self, country_id: int, name: str, link: str, iso: str):
-        self.id = country_id
-        self.name = name
-        self.link = link
-        self.iso = iso
-
-    def __repr__(self):
-        return f"Country({self.id}, '{self.name}', '{self.link}', '{self.iso}')"
-
-    def __str__(self):
-        return f"#{self.id} {self.name}"
-
-    def __format__(self, format_spec):
-        return self.iso
-
-    def __int__(self):
-        return self.id
-
-    def __eq__(self, other):
-        if isinstance(other, (int, float)):
-            return self.id == int(other)
-        else:
-            try:
-                return self.id == int(other)
-            except ValueError:
-                return self == other
-
-    @property
-    def __dict__(self):
-        return dict(id=self.id, name=self.name, iso=self.iso)
+__all__ = ['Battle', 'BattleDivision', 'BattleSide', 'Company', 'Config', 'Details', 'Energy', 'ErepublikException',
+           'Holding', 'MyCompanies', 'MyJSONEncoder', 'OfferItem', 'Politics', 'Reporter', 'TelegramBot']


 class ErepublikException(Exception):
@ -132,7 +90,7 @@ class Holding:
        return str(self)

    @property
-    def __dict__(self):
+    def as_dict(self):
        return dict(name=str(self), id=self.id, region=self.region, companies=self.companies, wam_count=self.wam_count)


@ -229,7 +187,7 @@ class Company:
        return self._sort_keys != other._sort_keys

    def __str__(self):
-        name = f"(#{self.id:>9d}) {INDUSTRIES[self.industry]}"
+        name = f"(#{self.id:>9d}) {constants.INDUSTRIES[self.industry]}"
        if not self.is_raw:
            name += f" q{self.quality}"
        return name
@ -238,7 +196,7 @@ class Company:
        return str(self)

    @property
-    def __dict__(self):
+    def as_dict(self):
        return dict(name=str(self), holding=self.holding.id, id=self.id, quality=self.quality, is_raw=self.is_raw,
                    raw_usage=self.raw_usage, products_made=self.products_made, wam_enabled=self.wam_enabled,
                    can_wam=self.can_wam, cannot_wam_reason=self.cannot_wam_reason, industry=self.industry,
@ -328,7 +286,7 @@ class MyCompanies:
        self.companies.clear()

    @property
-    def __dict__(self):
+    def as_dict(self):
        return dict(name=str(self), work_units=self.work_units, next_ot_time=self.next_ot_time,
                    ff_lockdown=self.ff_lockdown, holdings=self.holdings, company_count=len(self.companies))

@ -397,7 +355,7 @@ class Config:
        self.telegram_token = ""

    @property
-    def __dict__(self):
+    def as_dict(self):
        return dict(email=self.email, work=self.work, train=self.train, wam=self.wam, ot=self.ot,
                    auto_sell=self.auto_sell, auto_sell_all=self.auto_sell_all, employees=self.employees,
                    fight=self.fight, air=self.air, ground=self.ground, all_in=self.all_in,
@ -453,6 +411,13 @@ class Energy:
    def available(self):
        return self.recovered + self.recoverable

+    @property
+    def as_dict(self):
+        return dict(limit=self.limit, interval=self.interval, recoverable=self.recoverable, recovered=self.recovered,
+                    reference_time=self.reference_time, food_fights=self.food_fights,
+                    is_recoverable_full=self.is_recoverable_full, is_recovered_full=self.is_recovered_full,
+                    is_energy_full=self.is_energy_full, available=self.available)
+

 class Details:
    xp = 0
@ -462,11 +427,11 @@ class Details:
    gold = 0
    next_pp: List[int] = None
    citizen_id = 0
-    citizenship: Country
+    citizenship: constants.Country
    current_region = 0
-    current_country: Country
+    current_country: constants.Country
    residence_region = 0
-    residence_country: Country
+    residence_country: constants.Country
    daily_task_done = False
    daily_task_reward = False
    mayhem_skills = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, }
@ -500,6 +465,15 @@ class Details:
            next_level_up = (1 + (self.xp // 10)) * 10
        return next_level_up - self.xp

+    @property
+    def as_dict(self):
+        return dict(xp=self.xp, cc=self.cc, pp=self.pp, pin=self.pin, gold=self.gold, next_pp=self.next_pp,
+                    citizen_id=self.citizen_id, citizenship=self.citizenship, current_region=self.current_region,
+                    current_country=self.current_country, residence_region=self.residence_region,
+                    residence_country=self.residence_country, daily_task_done=self.daily_task_done,
+                    daily_task_reward=self.daily_task_reward, mayhem_skills=self.mayhem_skills,
+                    xp_till_level_up=self.xp_till_level_up)
+

 class Politics:
    is_party_member: bool = False
@ -510,6 +484,12 @@ class Politics:
    is_congressman: bool = False
    is_country_president: bool = False

+    @property
+    def as_dict(self):
+        return dict(is_party_member=self.is_party_member, party_id=self.party_id, party_slug=self.party_slug,
+                    is_party_president=self.is_party_president, is_congressman=self.is_congressman,
+                    is_country_president=self.is_country_president)
+

 class House:
    quality = None
@ -543,7 +523,7 @@ class Reporter:
        return self.citizen.details.citizen_id

    @property
-    def __dict__(self):
+    def as_dict(self):
        return dict(name=self.name, email=self.email, citizen_id=self.citizen_id, key=self.key, allowed=self.allowed,
                    queue=self.__to_update)

@ -568,8 +548,10 @@ class Reporter:
        if self.__to_update:
            for unreported_data in self.__to_update:
                unreported_data.update(player_id=self.citizen_id, key=self.key)
+                unreported_data = utils.json.load(utils.json.dumps(unreported_data, cls=MyJSONEncoder, sort_keys=True))
                self._req.post("{}/bot/update".format(self.url), json=unreported_data)
            self.__to_update.clear()
+        data = utils.json.loads(utils.json.dumps(data, cls=MyJSONEncoder, sort_keys=True))
        r = self._req.post("{}/bot/update".format(self.url), json=data)
        return r

@ -614,7 +596,7 @@ class Reporter:
    def report_promo(self, kind: str, time_until: datetime.datetime):
        self._req.post(f"{self.url}/promos/add/", data=dict(kind=kind, time_untill=time_until))

-    def fetch_battle_priorities(self, country: Country) -> List["Battle"]:
+    def fetch_battle_priorities(self, country: constants.Country) -> List["Battle"]:
        try:
            battle_response = self._req.get(f'{self.url}/api/v1/battles/{country.id}')
            return [self.citizen.all_battles[bid] for bid in battle_response.json().get('battle_ids', []) if
@ -631,7 +613,7 @@ class Reporter:
            return


-class MyJSONEncoder(json.JSONEncoder):
+class MyJSONEncoder(utils.json.JSONEncoder):
    def default(self, o):
        from erepublik.citizen import Citizen
        if isinstance(o, Decimal):
@ -646,8 +628,8 @@ class MyJSONEncoder(json.JSONEncoder):
                        microseconds=o.microseconds, total_seconds=o.total_seconds())
        elif isinstance(o, Response):
            return dict(headers=o.headers.__dict__, url=o.url, text=o.text)
-        elif hasattr(o, '__dict__'):
-            return o.__dict__
+        elif hasattr(o, 'as_dict'):
+            return o.as_dict
        elif isinstance(o, set):
            return list(o)
        elif isinstance(o, Citizen):
@ -660,14 +642,14 @@ class MyJSONEncoder(json.JSONEncoder):

 class BattleSide:
    points: int
-    deployed: List[Country]
-    allies: List[Country]
+    deployed: List[constants.Country]
+    allies: List[constants.Country]
    battle: "Battle"
-    country: Country
+    country: constants.Country
    defender: bool

-    def __init__(self, battle: "Battle", country: Country, points: int, allies: List[Country], deployed: List[Country],
-                 defender: bool):
+    def __init__(self, battle: "Battle", country: constants.Country, points: int, allies: List[constants.Country],
+                 deployed: List[constants.Country], defender: bool):
        self.battle = battle
        self.country = country
        self.points = points
@ -691,7 +673,7 @@ class BattleSide:
        return self.country.iso

    @property
-    def __dict__(self):
+    def as_dict(self):
        return dict(points=self.points, country=self.country, defender=self.defender, allies=self.allies,
                    deployed=self.deployed, battle=repr(self.battle))

@ -709,9 +691,9 @@ class BattleDivision:
    battle: "Battle"

    @property
-    def __dict__(self):
+    def as_dict(self):
        return dict(id=self.id, division=self.div, terrain=(self.terrain, self.terrain_display), wall=self.wall,
-                    dom_pts=self.dom_pts, epic=self.epic, battle=str(self.battle), end=self.div_end)
+                    epic=self.epic, battle=str(self.battle), end=self.div_end)

    @property
    def is_air(self):
@ -743,7 +725,7 @@ class BattleDivision:

    @property
    def terrain_display(self):
-        return _TERRAINS[self.terrain]
+        return constants.TERRAINS[self.terrain]

    def __str__(self):
        base_name = f"Div #{self.id} d{self.div}"
@ -771,7 +753,7 @@ class Battle:
    region_name: str

    @property
-    def __dict__(self):
+    def as_dict(self):
        return dict(id=self.id, war_id=self.war_id, divisions=self.div, zone=self.zone_id, rw=self.is_rw,
                    dict_lib=self.is_dict_lib, start=self.start, sides={'inv': self.invader, 'def': self.defender},
                    region=[self.region_id, self.region_name])
@ -805,27 +787,28 @@ class Battle:
        self.zone_id = int(battle.get('zone_id'))
        self.is_rw = bool(battle.get('is_rw'))
        self.is_as = bool(battle.get('is_as'))
+        self.is_dict_lib = bool(battle.get('is_dict')) or bool(battle.get('is_lib'))
        self.region_id = battle.get('region', {}).get('id')
        self.region_name = battle.get('region', {}).get('name')
-        self.start = datetime.datetime.fromtimestamp(int(battle.get('start', 0)), tz=utils.erep_tz)
+        self.start = datetime.datetime.fromtimestamp(int(battle.get('start', 0)), tz=constants.erep_tz)

        self.invader = BattleSide(
-            self, COUNTRIES[battle.get('inv', {}).get('id')], battle.get('inv', {}).get('points'),
-            [COUNTRIES[row.get('id')] for row in battle.get('inv', {}).get('ally_list')],
-            [COUNTRIES[row.get('id')] for row in battle.get('inv', {}).get('ally_list') if row['deployed']], False
+            self, constants.COUNTRIES[battle.get('inv', {}).get('id')], battle.get('inv', {}).get('points'),
+            [constants.COUNTRIES[row.get('id')] for row in battle.get('inv', {}).get('ally_list')],
+            [constants.COUNTRIES[row.get('id')] for row in battle.get('inv', {}).get('ally_list') if row['deployed']], False
        )

        self.defender = BattleSide(
-            self, COUNTRIES[battle.get('def', {}).get('id')], battle.get('def', {}).get('points'),
-            [COUNTRIES[row.get('id')] for row in battle.get('def', {}).get('ally_list')],
-            [COUNTRIES[row.get('id')] for row in battle.get('def', {}).get('ally_list') if row['deployed']], True
+            self, constants.COUNTRIES[battle.get('def', {}).get('id')], battle.get('def', {}).get('points'),
+            [constants.COUNTRIES[row.get('id')] for row in battle.get('def', {}).get('ally_list')],
+            [constants.COUNTRIES[row.get('id')] for row in battle.get('def', {}).get('ally_list') if row['deployed']], True
        )

        self.div = {}
        for div, data in battle.get('div', {}).items():
            div = int(div)
            if data.get('end'):
-                end = datetime.datetime.fromtimestamp(data.get('end'), tz=utils.erep_tz)
+                end = datetime.datetime.fromtimestamp(data.get('end'), tz=constants.erep_tz)
            else:
                end = utils.localize_dt(datetime.datetime.max - datetime.timedelta(days=1))

@ -838,12 +821,12 @@ class Battle:
            self.div.update({div: battle_div})

    def __str__(self):
-        now = utils.now()
+        time_now = utils.now()
        is_started = self.start < utils.now()
        if is_started:
-            time_part = " {}".format(now - self.start)
+            time_part = " {}".format(time_now - self.start)
        else:
-            time_part = "-{}".format(self.start - now)
+            time_part = "-{}".format(self.start - time_now)

        return f"Battle {self.id} for {self.region_name[:16]} | {self.invader} : {self.defender} | Round time {time_part}"

@ -902,7 +885,7 @@ class TelegramBot:
        self._next_time = utils.now()

    @property
-    def __dict__(self):
+    def as_dict(self):
        return {'chat_id': self.chat_id, 'api_url': self.api_url, 'player': self.player_name,
                'last_time': self._last_time, 'next_time': self._next_time, 'queue': self.__queue,
                'initialized': self.__initialized, 'has_threads': bool(len(self._threads))}
@ -962,54 +945,7 @@ class TelegramBot:

 class OfferItem(NamedTuple):
    price: float = 99_999.
-    country: Country = Country(0, "", "", "")
+    country: constants.Country = constants.Country(0, "", "", "")
    amount: int = 0
    offer_id: int = 0
    citizen_id: int = 0
-
-
-COUNTRIES: Dict[int, Country] = {
-    1: Country(1, 'Romania', 'Romania', 'ROU'), 9: Country(9, 'Brazil', 'Brazil', 'BRA'),
-    10: Country(10, 'Italy', 'Italy', 'ITA'), 11: Country(11, 'France', 'France', 'FRA'),
-    12: Country(12, 'Germany', 'Germany', 'DEU'), 13: Country(13, 'Hungary', 'Hungary', 'HUN'),
-    14: Country(14, 'China', 'China', 'CHN'), 15: Country(15, 'Spain', 'Spain', 'ESP'),
-    23: Country(23, 'Canada', 'Canada', 'CAN'), 24: Country(24, 'USA', 'USA', 'USA'),
-    26: Country(26, 'Mexico', 'Mexico', 'MEX'), 27: Country(27, 'Argentina', 'Argentina', 'ARG'),
-    28: Country(28, 'Venezuela', 'Venezuela', 'VEN'), 29: Country(29, 'United Kingdom', 'United-Kingdom', 'GBR'),
-    30: Country(30, 'Switzerland', 'Switzerland', 'CHE'), 31: Country(31, 'Netherlands', 'Netherlands', 'NLD'),
-    32: Country(32, 'Belgium', 'Belgium', 'BEL'), 33: Country(33, 'Austria', 'Austria', 'AUT'),
-    34: Country(34, 'Czech Republic', 'Czech-Republic', 'CZE'), 35: Country(35, 'Poland', 'Poland', 'POL'),
-    36: Country(36, 'Slovakia', 'Slovakia', 'SVK'), 37: Country(37, 'Norway', 'Norway', 'NOR'),
-    38: Country(38, 'Sweden', 'Sweden', 'SWE'), 39: Country(39, 'Finland', 'Finland', 'FIN'),
-    40: Country(40, 'Ukraine', 'Ukraine', 'UKR'), 41: Country(41, 'Russia', 'Russia', 'RUS'),
-    42: Country(42, 'Bulgaria', 'Bulgaria', 'BGR'), 43: Country(43, 'Turkey', 'Turkey', 'TUR'),
-    44: Country(44, 'Greece', 'Greece', 'GRC'), 45: Country(45, 'Japan', 'Japan', 'JPN'),
-    47: Country(47, 'South Korea', 'South-Korea', 'KOR'), 48: Country(48, 'India', 'India', 'IND'),
-    49: Country(49, 'Indonesia', 'Indonesia', 'IDN'), 50: Country(50, 'Australia', 'Australia', 'AUS'),
-    51: Country(51, 'South Africa', 'South Africa', 'ZAF'),
-    52: Country(52, 'Republic of Moldova', 'Republic-of-Moldova', 'MDA'),
-    53: Country(53, 'Portugal', 'Portugal', 'PRT'), 54: Country(54, 'Ireland', 'Ireland', 'IRL'),
-    55: Country(55, 'Denmark', 'Denmark', 'DNK'), 56: Country(56, 'Iran', 'Iran', 'IRN'),
-    57: Country(57, 'Pakistan', 'Pakistan', 'PAK'), 58: Country(58, 'Israel', 'Israel', 'ISR'),
-    59: Country(59, 'Thailand', 'Thailand', 'THA'), 61: Country(61, 'Slovenia', 'Slovenia', 'SVN'),
-    63: Country(63, 'Croatia', 'Croatia', 'HRV'), 64: Country(64, 'Chile', 'Chile', 'CHL'),
-    65: Country(65, 'Serbia', 'Serbia', 'SRB'), 66: Country(66, 'Malaysia', 'Malaysia', 'MYS'),
-    67: Country(67, 'Philippines', 'Philippines', 'PHL'), 68: Country(68, 'Singapore', 'Singapore', 'SGP'),
-    69: Country(69, 'Bosnia and Herzegovina', 'Bosnia-Herzegovina', 'BiH'),
-    70: Country(70, 'Estonia', 'Estonia', 'EST'), 80: Country(80, 'Montenegro', 'Montenegro', 'MNE'),
-    71: Country(71, 'Latvia', 'Latvia', 'LVA'), 72: Country(72, 'Lithuania', 'Lithuania', 'LTU'),
-    73: Country(73, 'North Korea', 'North-Korea', 'PRK'), 74: Country(74, 'Uruguay', 'Uruguay', 'URY'),
-    75: Country(75, 'Paraguay', 'Paraguay', 'PRY'), 76: Country(76, 'Bolivia', 'Bolivia', 'BOL'),
-    77: Country(77, 'Peru', 'Peru', 'PER'), 78: Country(78, 'Colombia', 'Colombia', 'COL'),
-    79: Country(79, 'Republic of Macedonia (FYROM)', 'Republic-of-Macedonia-FYROM', 'MKD'),
-    81: Country(81, 'Republic of China (Taiwan)', 'Republic-of-China-Taiwan', 'TWN'),
-    82: Country(82, 'Cyprus', 'Cyprus', 'CYP'), 167: Country(167, 'Albania', 'Albania', 'ALB'),
-    83: Country(83, 'Belarus', 'Belarus', 'BLR'), 84: Country(84, 'New Zealand', 'New-Zealand', 'NZL'),
-    164: Country(164, 'Saudi Arabia', 'Saudi-Arabia', 'SAU'), 165: Country(165, 'Egypt', 'Egypt', 'EGY'),
-    166: Country(166, 'United Arab Emirates', 'United-Arab-Emirates', 'UAE'),
-    168: Country(168, 'Georgia', 'Georgia', 'GEO'), 169: Country(169, 'Armenia', 'Armenia', 'ARM'),
-    170: Country(170, 'Nigeria', 'Nigeria', 'NGA'), 171: Country(171, 'Cuba', 'Cuba', 'CUB')
-}
-
-_TERRAINS = {0: "Standard", 1: 'Industrial', 2: 'Urban', 3: 'Suburbs', 4: 'Airport', 5: 'Plains', 6: 'Wasteland',
-             7: 'Mountains', 8: 'Beach', 9: 'Swamp', 10: 'Mud', 11: 'Hills', 12: 'Jungle', 13: 'Forest', 14: 'Desert'}
--- a/erepublik/constants.py
+++ b/erepublik/constants.py
@ -0,0 +1,187 @@
+from typing import Dict, Optional, Union
+
+import pytz
+
+__all__ = ["erep_tz", "Country", "AIR_RANKS", "COUNTRIES", "FOOD_ENERGY", "GROUND_RANKS", "GROUND_RANK_POINTS", "INDUSTRIES", "TERRAINS"]
+
+erep_tz = pytz.timezone('US/Pacific')
+
+
+class Country:
+    id: int
+    name: str
+    link: str
+    iso: str
+
+    def __init__(self, country_id: int, name: str, link: str, iso: str):
+        self.id = country_id
+        self.name = name
+        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}')"
+
+    def __str__(self):
+        return f"#{self.id} {self.name}"
+
+    def __format__(self, format_spec):
+        return self.iso
+
+    def __int__(self):
+        return self.id
+
+    def __eq__(self, other):
+        if isinstance(other, (int, float)):
+            return self.id == int(other)
+        else:
+            try:
+                return self.id == int(other)
+            except ValueError:
+                return self == other
+
+    @property
+    def as_dict(self):
+        return dict(id=self.id, name=self.name, iso=self.iso)
+
+
+class Industries:
+    __by_name = {'food': 1, 'weapons': 2, 'house': 4, 'aircraft': 23,
+                 '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,
+                 'hrm q1': 18, 'hrm q2': 19, 'hrm q3': 20, 'hrm q4': 21, 'hrm q5': 22,
+                 'arm q1': 24, 'arm q2': 25, 'arm q3': 26, 'arm q4': 27, 'arm q5': 28}
+    __by_id = {1: "Food", 2: "Weapons", 4: "House", 23: "Aircraft",
+               7: "foodRaw", 8: "FRM q2", 9: "FRM q3", 10: "FRM q4", 11: "FRM q5",
+               12: "weaponsRaw", 13: "WRM q2", 14: "WRM q3", 15: "WRM q4", 16: "WRM q5",
+               18: "houseRaw", 19: "HRM q2", 20: "HRM q3", 21: "HRM q4", 22: "HRM q5",
+               24: "aircraftRaw", 25: "ARM q2", 26: "ARM q3", 27: "ARM q4", 28: "ARM q5"}
+
+    def __getitem__(self, item) -> Optional[Union[int, str]]:
+        if isinstance(item, int):
+            return self.__by_id.get(item, None)
+        elif isinstance(item, str):
+            return self.__by_name.get(item.lower(), None)
+        return
+
+    def __getattr__(self, item) -> Optional[Union[int, str]]:
+        return self[item]
+
+    @property
+    def as_dict(self):
+        return dict(by_id=self.__by_id, by_name=self.__by_name)
+
+
+AIR_RANKS: Dict[int, str] = {
+    1: "Airman", 2: "Airman 1st Class", 3: "Airman 1st Class*", 4: "Airman 1st Class**", 5: "Airman 1st Class***",
+    6: "Airman 1st Class****", 7: "Airman 1st Class*****", 8: "Senior Airman", 9: "Senior Airman*",
+    10: "Senior Airman**", 11: "Senior Airman***", 12: "Senior Airman****", 13: "Senior Airman*****",
+    14: "Staff Sergeant", 15: "Staff Sergeant*", 16: "Staff Sergeant**", 17: "Staff Sergeant***",
+    18: "Staff Sergeant****", 19: "Staff Sergeant*****", 20: "Aviator", 21: "Aviator*", 22: "Aviator**",
+    23: "Aviator***", 24: "Aviator****", 25: "Aviator*****", 26: "Flight Lieutenant", 27: "Flight Lieutenant*",
+    28: "Flight Lieutenant**", 29: "Flight Lieutenant***", 30: "Flight Lieutenant****", 31: "Flight Lieutenant*****",
+    32: "Squadron Leader", 33: "Squadron Leader*", 34: "Squadron Leader**", 35: "Squadron Leader***",
+    36: "Squadron Leader****", 37: "Squadron Leader*****", 38: "Chief Master Sergeant", 39: "Chief Master Sergeant*",
+    40: "Chief Master Sergeant**", 41: "Chief Master Sergeant***", 42: "Chief Master Sergeant****",
+    43: "Chief Master Sergeant*****", 44: "Wing Commander", 45: "Wing Commander*", 46: "Wing Commander**",
+    47: "Wing Commander***", 48: "Wing Commander****", 49: "Wing Commander*****", 50: "Group Captain",
+    51: "Group Captain*", 52: "Group Captain**", 53: "Group Captain***", 54: "Group Captain****",
+    55: "Group Captain*****", 56: "Air Commodore", 57: "Air Commodore*", 58: "Air Commodore**", 59: "Air Commodore***",
+    60: "Air Commodore****", 61: "Air Commodore*****",
+}
+
+COUNTRIES: Dict[int, Country] = {
+    1: Country(1, 'Romania', 'Romania', 'ROU'), 9: Country(9, 'Brazil', 'Brazil', 'BRA'),
+    10: Country(10, 'Italy', 'Italy', 'ITA'), 11: Country(11, 'France', 'France', 'FRA'),
+    12: Country(12, 'Germany', 'Germany', 'DEU'), 13: Country(13, 'Hungary', 'Hungary', 'HUN'),
+    14: Country(14, 'China', 'China', 'CHN'), 15: Country(15, 'Spain', 'Spain', 'ESP'),
+    23: Country(23, 'Canada', 'Canada', 'CAN'), 24: Country(24, 'USA', 'USA', 'USA'),
+    26: Country(26, 'Mexico', 'Mexico', 'MEX'), 27: Country(27, 'Argentina', 'Argentina', 'ARG'),
+    28: Country(28, 'Venezuela', 'Venezuela', 'VEN'), 29: Country(29, 'United Kingdom', 'United-Kingdom', 'GBR'),
+    30: Country(30, 'Switzerland', 'Switzerland', 'CHE'), 31: Country(31, 'Netherlands', 'Netherlands', 'NLD'),
+    32: Country(32, 'Belgium', 'Belgium', 'BEL'), 33: Country(33, 'Austria', 'Austria', 'AUT'),
+    34: Country(34, 'Czech Republic', 'Czech-Republic', 'CZE'), 35: Country(35, 'Poland', 'Poland', 'POL'),
+    36: Country(36, 'Slovakia', 'Slovakia', 'SVK'), 37: Country(37, 'Norway', 'Norway', 'NOR'),
+    38: Country(38, 'Sweden', 'Sweden', 'SWE'), 39: Country(39, 'Finland', 'Finland', 'FIN'),
+    40: Country(40, 'Ukraine', 'Ukraine', 'UKR'), 41: Country(41, 'Russia', 'Russia', 'RUS'),
+    42: Country(42, 'Bulgaria', 'Bulgaria', 'BGR'), 43: Country(43, 'Turkey', 'Turkey', 'TUR'),
+    44: Country(44, 'Greece', 'Greece', 'GRC'), 45: Country(45, 'Japan', 'Japan', 'JPN'),
+    47: Country(47, 'South Korea', 'South-Korea', 'KOR'), 48: Country(48, 'India', 'India', 'IND'),
+    49: Country(49, 'Indonesia', 'Indonesia', 'IDN'), 50: Country(50, 'Australia', 'Australia', 'AUS'),
+    51: Country(51, 'South Africa', 'South-Africa', 'ZAF'),
+    52: Country(52, 'Republic of Moldova', 'Republic-of-Moldova', 'MDA'),
+    53: Country(53, 'Portugal', 'Portugal', 'PRT'), 54: Country(54, 'Ireland', 'Ireland', 'IRL'),
+    55: Country(55, 'Denmark', 'Denmark', 'DNK'), 56: Country(56, 'Iran', 'Iran', 'IRN'),
+    57: Country(57, 'Pakistan', 'Pakistan', 'PAK'), 58: Country(58, 'Israel', 'Israel', 'ISR'),
+    59: Country(59, 'Thailand', 'Thailand', 'THA'), 61: Country(61, 'Slovenia', 'Slovenia', 'SVN'),
+    63: Country(63, 'Croatia', 'Croatia', 'HRV'), 64: Country(64, 'Chile', 'Chile', 'CHL'),
+    65: Country(65, 'Serbia', 'Serbia', 'SRB'), 66: Country(66, 'Malaysia', 'Malaysia', 'MYS'),
+    67: Country(67, 'Philippines', 'Philippines', 'PHL'), 68: Country(68, 'Singapore', 'Singapore', 'SGP'),
+    69: Country(69, 'Bosnia and Herzegovina', 'Bosnia-Herzegovina', 'BiH'),
+    70: Country(70, 'Estonia', 'Estonia', 'EST'), 80: Country(80, 'Montenegro', 'Montenegro', 'MNE'),
+    71: Country(71, 'Latvia', 'Latvia', 'LVA'), 72: Country(72, 'Lithuania', 'Lithuania', 'LTU'),
+    73: Country(73, 'North Korea', 'North-Korea', 'PRK'), 74: Country(74, 'Uruguay', 'Uruguay', 'URY'),
+    75: Country(75, 'Paraguay', 'Paraguay', 'PRY'), 76: Country(76, 'Bolivia', 'Bolivia', 'BOL'),
+    77: Country(77, 'Peru', 'Peru', 'PER'), 78: Country(78, 'Colombia', 'Colombia', 'COL'),
+    79: Country(79, 'Republic of Macedonia (FYROM)', 'Republic-of-Macedonia-FYROM', 'MKD'),
+    81: Country(81, 'Republic of China (Taiwan)', 'Republic-of-China-Taiwan', 'TWN'),
+    82: Country(82, 'Cyprus', 'Cyprus', 'CYP'), 167: Country(167, 'Albania', 'Albania', 'ALB'),
+    83: Country(83, 'Belarus', 'Belarus', 'BLR'), 84: Country(84, 'New Zealand', 'New-Zealand', 'NZL'),
+    164: Country(164, 'Saudi Arabia', 'Saudi-Arabia', 'SAU'), 165: Country(165, 'Egypt', 'Egypt', 'EGY'),
+    166: Country(166, 'United Arab Emirates', 'United-Arab-Emirates', 'UAE'),
+    168: Country(168, 'Georgia', 'Georgia', 'GEO'), 169: Country(169, 'Armenia', 'Armenia', 'ARM'),
+    170: Country(170, 'Nigeria', 'Nigeria', 'NGA'), 171: Country(171, 'Cuba', 'Cuba', 'CUB')
+}
+
+FOOD_ENERGY: Dict[str, int] = dict(q1=2, q2=4, q3=6, q4=8, q5=10, q6=12, q7=20)
+
+GROUND_RANKS: Dict[int, str] = {
+    1: "Recruit", 2: "Private", 3: "Private*", 4: "Private**", 5: "Private***",
+    6: "Corporal", 7: "Corporal*", 8: "Corporal**", 9: "Corporal***",
+    10: "Sergeant", 11: "Sergeant*", 12: "Sergeant**", 13: "Sergeant***",
+    14: "Lieutenant", 15: "Lieutenant*", 16: "Lieutenant**", 17: "Lieutenant***",
+    18: "Captain", 19: "Captain*", 20: "Captain**", 21: "Captain***",
+    22: "Major", 23: "Major*", 24: "Major**", 25: "Major***",
+    26: "Commander", 27: "Commander*", 28: "Commander**", 29: "Commander***",
+    30: "Lt Colonel", 31: "Lt Colonel*", 32: "Lt Colonel**", 33: "Lt Colonel***",
+    34: "Colonel", 35: "Colonel*", 36: "Colonel**", 37: "Colonel***",
+    38: "General", 39: "General*", 40: "General**", 41: "General***",
+    42: "Field Marshal", 43: "Field Marshal*", 44: "Field Marshal**", 45: "Field Marshal***",
+    46: "Supreme Marshal", 47: "Supreme Marshal*", 48: "Supreme Marshal**", 49: "Supreme Marshal***",
+    50: "National Force", 51: "National Force*", 52: "National Force**", 53: "National Force***",
+    54: "World Class Force", 55: "World Class Force*", 56: "World Class Force**", 57: "World Class Force***",
+    58: "Legendary Force", 59: "Legendary Force*", 60: "Legendary Force**", 61: "Legendary Force***",
+    62: "God of War", 63: "God of War*", 64: "God of War**", 65: "God of War***",
+    66: "Titan", 67: "Titan*", 68: "Titan**", 69: "Titan***",
+    70: "Legends I", 71: "Legends II", 72: "Legends III", 73: "Legends IV", 74: "Legends V", 75: "Legends VI",
+    76: "Legends VII", 77: "Legends VIII", 78: "Legends IX", 79: "Legends X", 80: "Legends XI", 81: "Legends XII",
+    82: "Legends XIII", 83: "Legends XIV", 84: "Legends XV", 85: "Legends XVI", 86: "Legends XVII", 87: "Legends XVIII",
+    88: "Legends XIX", 89: "Legends XX",
+}
+
+GROUND_RANK_POINTS: Dict[int, int] = {
+    1: 0, 2: 15, 3: 45, 4: 80, 5: 120, 6: 170, 7: 250, 8: 350, 9: 450, 10: 600, 11: 800, 12: 1000,
+    13: 1400, 14: 1850, 15: 2350, 16: 3000, 17: 3750, 18: 5000, 19: 6500, 20: 9000, 21: 12000,
+    22: 15500, 23: 20000, 24: 25000, 25: 31000, 26: 40000, 27: 52000, 28: 67000, 29: 85000,
+    30: 110000, 31: 140000, 32: 180000, 33: 225000, 34: 285000, 35: 355000, 36: 435000, 37: 540000,
+    38: 660000, 39: 800000, 40: 950000, 41: 1140000, 42: 1350000, 43: 1600000, 44: 1875000,
+    45: 2185000, 46: 2550000, 47: 3000000, 48: 3500000, 49: 4150000, 50: 4900000, 51: 5800000,
+    52: 7000000, 53: 9000000, 54: 11500000, 55: 14500000, 56: 18000000, 57: 22000000, 58: 26500000,
+    59: 31500000, 60: 37000000, 61: 43000000, 62: 50000000, 63: 100000000, 64: 200000000,
+    65: 500000000, 66: 1000000000, 67: 2000000000, 68: 4000000000, 69: 10000000000, 70: 20000000000,
+    71: 30000000000, 72: 40000000000, 73: 50000000000, 74: 60000000000, 75: 70000000000,
+    76: 80000000000, 77: 90000000000, 78: 100000000000, 79: 110000000000, 80: 120000000000,
+    81: 130000000000, 82: 140000000000, 83: 150000000000, 84: 160000000000, 85: 170000000000,
+    86: 180000000000, 87: 190000000000, 88: 200000000000, 89: 210000000000
+}
+
+INDUSTRIES = Industries()
+
+TERRAINS: Dict[int, str] = {0: "Standard", 1: 'Industrial', 2: 'Urban', 3: 'Suburbs', 4: 'Airport', 5: 'Plains',
+                            6: 'Wasteland', 7: 'Mountains', 8: 'Beach', 9: 'Swamp', 10: 'Mud', 11: 'Hills',
+                            12: 'Jungle', 13: 'Forest', 14: 'Desert'}
--- a/erepublik/utils.py
+++ b/erepublik/utils.py
@ -1,3 +1,4 @@
+import copy
 import datetime
 import inspect
 import os
@ -9,109 +10,46 @@ import traceback
 import unicodedata
 from decimal import Decimal
 from pathlib import Path
-from typing import Any, Dict, List, Mapping, Optional, Union
+from typing import Any, List, Mapping, Optional, Union, Dict

-import pytz
 import requests

-from . import __commit_id__, __version__
+from . import __version__, constants

 try:
    import simplejson as json
 except ImportError:
    import json

-__all__ = ["FOOD_ENERGY", "COMMIT_ID", "erep_tz",
-           "now", "localize_dt", "localize_timestamp", "good_timedelta", "eday_from_date", "date_from_eday",
-           "get_sleep_seconds", "interactive_sleep", "silent_sleep",
-           "write_silent_log", "write_interactive_log", "get_file", "write_file",
-           "send_email", "normalize_html_json", "process_error", "process_warning",
-           'calculate_hit', 'get_ground_hit_dmg_value', 'get_air_hit_dmg_value']
+__all__ = ['VERSION', 'calculate_hit', 'caught_error', 'date_from_eday', 'eday_from_date',
+           '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']

 if not sys.version_info >= (3, 7):
    raise AssertionError('This script requires Python version 3.7 and higher\n'
                         'But Your version is v{}.{}.{}'.format(*sys.version_info))

-FOOD_ENERGY: Dict[str, int] = dict(q1=2, q2=4, q3=6, q4=8, q5=10, q6=12, q7=20)
-COMMIT_ID: str = __commit_id__
 VERSION: str = __version__

-erep_tz = pytz.timezone('US/Pacific')
-AIR_RANKS: Dict[int, str] = {
-    1: "Airman", 2: "Airman 1st Class", 3: "Airman 1st Class*", 4: "Airman 1st Class**", 5: "Airman 1st Class***",
-    6: "Airman 1st Class****", 7: "Airman 1st Class*****", 8: "Senior Airman", 9: "Senior Airman*",
-    10: "Senior Airman**", 11: "Senior Airman***", 12: "Senior Airman****", 13: "Senior Airman*****",
-    14: "Staff Sergeant", 15: "Staff Sergeant*", 16: "Staff Sergeant**", 17: "Staff Sergeant***",
-    18: "Staff Sergeant****", 19: "Staff Sergeant*****", 20: "Aviator", 21: "Aviator*", 22: "Aviator**",
-    23: "Aviator***", 24: "Aviator****", 25: "Aviator*****", 26: "Flight Lieutenant", 27: "Flight Lieutenant*",
-    28: "Flight Lieutenant**", 29: "Flight Lieutenant***", 30: "Flight Lieutenant****", 31: "Flight Lieutenant*****",
-    32: "Squadron Leader", 33: "Squadron Leader*", 34: "Squadron Leader**", 35: "Squadron Leader***",
-    36: "Squadron Leader****", 37: "Squadron Leader*****", 38: "Chief Master Sergeant", 39: "Chief Master Sergeant*",
-    40: "Chief Master Sergeant**", 41: "Chief Master Sergeant***", 42: "Chief Master Sergeant****",
-    43: "Chief Master Sergeant*****", 44: "Wing Commander", 45: "Wing Commander*", 46: "Wing Commander**",
-    47: "Wing Commander***", 48: "Wing Commander****", 49: "Wing Commander*****", 50: "Group Captain",
-    51: "Group Captain*", 52: "Group Captain**", 53: "Group Captain***", 54: "Group Captain****",
-    55: "Group Captain*****", 56: "Air Commodore", 57: "Air Commodore*", 58: "Air Commodore**", 59: "Air Commodore***",
-    60: "Air Commodore****", 61: "Air Commodore*****",
-}
-
-GROUND_RANKS: Dict[int, str] = {
-    1: "Recruit", 2: "Private", 3: "Private*", 4: "Private**", 5: "Private***",
-    6: "Corporal", 7: "Corporal*", 8: "Corporal**", 9: "Corporal***",
-    10: "Sergeant", 11: "Sergeant*", 12: "Sergeant**", 13: "Sergeant***",
-    14: "Lieutenant", 15: "Lieutenant*", 16: "Lieutenant**", 17: "Lieutenant***",
-    18: "Captain", 19: "Captain*", 20: "Captain**", 21: "Captain***",
-    22: "Major", 23: "Major*", 24: "Major**", 25: "Major***",
-    26: "Commander", 27: "Commander*", 28: "Commander**", 29: "Commander***",
-    30: "Lt Colonel", 31: "Lt Colonel*", 32: "Lt Colonel**", 33: "Lt Colonel***",
-    34: "Colonel", 35: "Colonel*", 36: "Colonel**", 37: "Colonel***",
-    38: "General", 39: "General*", 40: "General**", 41: "General***",
-    42: "Field Marshal", 43: "Field Marshal*", 44: "Field Marshal**", 45: "Field Marshal***",
-    46: "Supreme Marshal", 47: "Supreme Marshal*", 48: "Supreme Marshal**", 49: "Supreme Marshal***",
-    50: "National Force", 51: "National Force*", 52: "National Force**", 53: "National Force***",
-    54: "World Class Force", 55: "World Class Force*", 56: "World Class Force**", 57: "World Class Force***",
-    58: "Legendary Force", 59: "Legendary Force*", 60: "Legendary Force**", 61: "Legendary Force***",
-    62: "God of War", 63: "God of War*", 64: "God of War**", 65: "God of War***",
-    66: "Titan", 67: "Titan*", 68: "Titan**", 69: "Titan***",
-    70: "Legends I", 71: "Legends II", 72: "Legends III", 73: "Legends IV", 74: "Legends V", 75: "Legends VI",
-    76: "Legends VII", 77: "Legends VIII", 78: "Legends IX", 79: "Legends X", 80: "Legends XI", 81: "Legends XII",
-    82: "Legends XIII", 83: "Legends XIV", 84: "Legends XV", 85: "Legends XVI", 86: "Legends XVII", 87: "Legends XVIII",
-    88: "Legends XIX", 89: "Legends XX",
-}
-
-GROUND_RANK_POINTS: Dict[int, int] = {
-    1: 0, 2: 15, 3: 45, 4: 80, 5: 120, 6: 170, 7: 250, 8: 350, 9: 450, 10: 600, 11: 800, 12: 1000,
-    13: 1400, 14: 1850, 15: 2350, 16: 3000, 17: 3750, 18: 5000, 19: 6500, 20: 9000, 21: 12000,
-    22: 15500, 23: 20000, 24: 25000, 25: 31000, 26: 40000, 27: 52000, 28: 67000, 29: 85000,
-    30: 110000, 31: 140000, 32: 180000, 33: 225000, 34: 285000, 35: 355000, 36: 435000, 37: 540000,
-    38: 660000, 39: 800000, 40: 950000, 41: 1140000, 42: 1350000, 43: 1600000, 44: 1875000,
-    45: 2185000, 46: 2550000, 47: 3000000, 48: 3500000, 49: 4150000, 50: 4900000, 51: 5800000,
-    52: 7000000, 53: 9000000, 54: 11500000, 55: 14500000, 56: 18000000, 57: 22000000, 58: 26500000,
-    59: 31500000, 60: 37000000, 61: 43000000, 62: 50000000, 63: 100000000, 64: 200000000,
-    65: 500000000, 66: 1000000000, 67: 2000000000, 68: 4000000000, 69: 10000000000, 70: 20000000000,
-    71: 30000000000, 72: 40000000000, 73: 50000000000, 74: 60000000000, 75: 70000000000,
-    76: 80000000000, 77: 90000000000, 78: 100000000000, 79: 110000000000, 80: 120000000000,
-    81: 130000000000, 82: 140000000000, 83: 150000000000, 84: 160000000000, 85: 170000000000,
-    86: 180000000000, 87: 190000000000, 88: 200000000000, 89: 210000000000
-}
-

 def now() -> datetime.datetime:
-    return datetime.datetime.now(erep_tz).replace(microsecond=0)
+    return datetime.datetime.now(constants.erep_tz).replace(microsecond=0)


 def localize_timestamp(timestamp: int) -> datetime.datetime:
-    return datetime.datetime.fromtimestamp(timestamp, erep_tz)
+    return datetime.datetime.fromtimestamp(timestamp, constants.erep_tz)


 def localize_dt(dt: Union[datetime.date, datetime.datetime]) -> datetime.datetime:
    try:
        try:
-            return erep_tz.localize(dt)
+            return constants.erep_tz.localize(dt)
        except AttributeError:
-            return erep_tz.localize(datetime.datetime.combine(dt, datetime.time(0, 0, 0)))
+            return constants.erep_tz.localize(datetime.datetime.combine(dt, datetime.time(0, 0, 0)))
    except ValueError:
-        return dt.astimezone(erep_tz)
+        return dt.astimezone(constants.erep_tz)


 def good_timedelta(dt: datetime.datetime, td: datetime.timedelta) -> datetime.datetime:
@ -124,7 +62,7 @@ def good_timedelta(dt: datetime.datetime, td: datetime.timedelta) -> datetime.da
    :return: datetime object with correct timezone when jumped over DST
    :rtype: datetime.datetime
    """
-    return erep_tz.normalize(dt + td)
+    return constants.erep_tz.normalize(dt + td)


 def eday_from_date(date: Union[datetime.date, datetime.datetime] = now()) -> int:
@ -240,14 +178,14 @@ 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 = {}
    from erepublik import Citizen

    file_content_template = "<html><head><title>{title}</title></head><body>{body}</body></html>"
-    if isinstance(player, Citizen):
+    if isinstance(player, Citizen) and player.r:
        resp = write_request(player.r, is_error=True)
    else:
        resp = {"name": "None.html", "mimetype": "text/html",
@ -283,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")))
@ -300,7 +246,7 @@ def normalize_html_json(js: str) -> str:


 def caught_error(e: Exception):
-    process_error(str(e), "Unclassified", sys.exc_info(), None, COMMIT_ID, False)
+    process_error(str(e), "Unclassified", sys.exc_info(), interactive=False)


 def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commit_id: str = None,
@ -322,7 +268,7 @@ def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commi
    """
    type_, value_, traceback_ = exc_info
    content = [log_info]
-    content += [f"eRepublik version {VERSION}, commit id {COMMIT_ID}"]
+    content += [f"eRepublik version {VERSION}"]
    if commit_id:
        content += [f"Commit id {commit_id}"]
    content += [str(value_), str(type_), ''.join(traceback.format_tb(traceback_))]
--- a/requirements_dev.txt
+++ b/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
-isort==4.3.21
+ipython==7.16.1
+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
-Sphinx==3.1.1
-tox==3.15.2
-twine==3.1.1
-watchdog==0.10.2
+setuptools==49.2.0
+Sphinx==3.1.2
+tox==3.16.1
+twine==3.2.0
+watchdog==0.10.3
 wheel==0.34.2
--- a/set_commit_id.sh
+++ b/set_commit_id.sh
@ -1,5 +0,0 @@
-#!/bin/bash
-
-commit=$(git log -1 --pretty=format:%h)
-sed -i.bak -E "s|__commit_id__ = \".+\"|__commit_id__ = \"${commit}\"|g" erepublik/__init__.py
-rm erepublik/__init__.py.bak
--- a/setup.cfg
+++ b/setup.cfg
@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.20.3.4
+current_version = 0.21.1
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)\.?(?P<dev>\d+)?
--- a/setup.py
+++ b/setup.py
@ -11,7 +11,7 @@ with open('README.rst') as readme_file:
 with open('HISTORY.rst') as history_file:
    history = history_file.read()

-requirements = ['pytz==2020.1', 'requests==2.23.0']
+requirements = ['pytz==2020.1', 'requests==2.24.0']

 setup_requirements = []

@ -43,6 +43,6 @@ setup(
    test_suite='tests',
    tests_require=test_requirements,
    url='https://github.com/eeriks/erepublik/',
-    version='0.20.3.4',
+    version='0.21.1',
    zip_safe=False,
 )
Author	SHA1	Message	Date
Eriks K	edb4d8851b	Bump version: 0.21.0.3 → 0.21.1	2020-07-16 11:15:04 +03:00
Eriks K	76edd6bb7d	Update traveling to incorporate travel cooldown (1travel / 15sec)	2020-07-16 11:14:35 +03:00
Eriks K	8da376b852	Change variable names to be more precise if argument must be and id or instance (battle/battle_id, division/division_id)	2020-07-16 11:13:29 +03:00
Eriks K	b6b0be7442	Minimize error reporting locals to not duplicate instance.json data	2020-07-16 11:11:35 +03:00
Eriks K	ed434b605d	Refactor '.format()' calls to f-strings	2020-07-16 11:08:31 +03:00
Eriks K	2bd311def6	Dev requirement update	2020-07-14 15:37:59 +03:00
Ēriks Karls	4b437c2ba6	Update README.rst	2020-07-14 14:11:20 +03:00
Ēriks Karls	cc8a1450d4	Merge pull request #3 from codacy-badger/codacy-badge Add a Codacy badge to README.rst	2020-07-14 14:08:45 +03:00
The Codacy Badger	0c9f3756ea	Add Codacy badge	2020-07-14 11:07:36 +00:00
Eriks K	9de07950b8	Bump version: 0.21.0.2 → 0.21.0.3	2020-07-13 11:24:29 +03:00
Eriks Karls	766b7b2d95	bugfix	2020-07-12 10:45:44 +03:00
Eriks K	c730981865	Bump version: 0.21.0.1 → 0.21.0.2	2020-07-11 10:21:21 +03:00
Eriks K	d70c3e2c9e	Typos	2020-07-11 10:21:12 +03:00
Eriks K	d044af6d2f	Bump version: 0.21.0 → 0.21.0.1	2020-07-11 10:08:09 +03:00
Eriks K	dd75b10d2f	missing __hash__	2020-07-11 09:54:23 +03:00
Eriks K	a45dd7e0c3	Bump version: 0.20.4 → 0.21.0	2020-07-11 09:39:25 +03:00
Eriks K	316a826c93	Merge branch 'master' of github.com:eeriks/erepublik	2020-07-11 09:38:20 +03:00
Eriks Karls	c9710733e2	Typo	2020-07-11 09:37:22 +03:00
Eriks K	9e678d6b51	Bump version: 0.20.3.11 → 0.20.4	2020-07-10 17:13:15 +03:00
Eriks K	88517cb076	Bugfix	2020-07-10 17:09:28 +03:00
Eriks K	01c8aef012	Bugfix: South Africa link	2020-07-10 17:08:58 +03:00
Eriks K	d7ac66bd69	Bump version: 0.20.3.10 → 0.20.3.11	2020-07-10 12:16:53 +03:00
Eriks K	e8739caca1	fix	2020-07-10 12:16:18 +03:00
Eriks K	9df9c1cd87	Bump version: 0.20.3.9 → 0.20.3.10	2020-07-10 00:47:42 +03:00
Eriks K	1b004f163a	bugfix	2020-07-10 00:47:36 +03:00
Eriks K	72bd2787d3	Bump version: 0.20.3.8 → 0.20.3.9	2020-07-09 19:11:04 +03:00
Eriks K	bfa6cb1e78	bugfix	2020-07-09 19:10:55 +03:00
Eriks K	1db7c98b47	Bump version: 0.20.3.7 → 0.20.3.8	2020-07-09 18:51:09 +03:00
Eriks K	1f21a71c74	bugfix	2020-07-09 18:51:00 +03:00
Eriks K	0531c8997b	Bump version: 0.20.3.6 → 0.20.3.7	2020-07-09 17:42:24 +03:00
Eriks K	5a8a0a3920	mavericks	2020-07-09 17:42:15 +03:00
Eriks K	d938908986	Bump version: 0.20.3.5 → 0.20.3.6	2020-07-09 14:42:51 +03:00
Eriks K	ffbbd25e54	Code cleanup	2020-07-09 14:42:40 +03:00
Eriks K	81bd09e13e	Bump version: 0.20.3.4 → 0.20.3.5	2020-07-09 08:53:45 +03:00
Eriks K	fc4295d8bd	bugix	2020-07-09 08:53:32 +03:00