Bump version: 0.23.2.2 → 0.23.2.3

`{"stock":10.494533,"consume":10.5}` rounds to 0

.gitignore

@@ -104,3 +104,4 @@ ENV/
 debug/
 log/
 docs/
+*dump.json

HISTORY.rst

@@ -2,6 +2,57 @@
 History
 =======
 
+0.23.2 (2020-12-01)
+-------------------
+* Added concurrency checks to guard against simultaneous fighting/wam'ing/traveling
+* For concurrency checking use `utils.wait_for_lock` decorator
+
+0.23.1 (2020-12-01)
+-------------------
+* Separated battle finding logic from CitizenMilitary.find_battle_and_fight method
+* Base dmg calculations
+* Get max hit value for divisions on current side
+* Added method to get division stats
+* Wheel of fortune updates
+
+0.23.0 (2020-11-26)
+-------------------
+* ***0.23 - last supported version for Python 3.7.***
+* Added `Config.maverick` switch, to allow/deny automated fighting in non native divisions if the player has MaverickPack
+* Added `CitizenMedia.get_article(article_id:int)` method to get article data
+* Added `CitizenMedia.delete_article(article_id:int)` method to delete article
+* Fixed `CitizenTravel.travel_to_region(region_id:int)` method
+* Added `CitizenAnniversary.collect_map_quest_node(node_id:int, extra:bool=False)` to collect also extra rewards
+* Fixed `CitizenTasks.work()` when employer out of money - resign and find a new job
+* Fixed `CitizenEconomy.post_market_offer()`
+
+0.22.3 (2020-11-16)
+-------------------
+* Fixed round to even bug when doing wam and not enough raw.
+* Added meta industry airplaneRaw
+* Added method `Citizen.buy_market_offer(OfferItem, amount=None)` to directly buy market offer with included travel to country and back.
+
+0.22.2 (2020-11-09)
+-------------------
+* Allow querying market offers for q2-q5 aircrafts
+* Added "Ticket" industry
+
+0.22.1 (2020-11-04)
+-------------------
+* Requirement update
+* Unified product naming in inventory and other places based on `erepublik.constants.INDUSTRIES` values
+* `erepublik.Citizen` parameter `auto_login` now defaults to `False`
+* Continued work on more verbose action and result logging
+
+0.22.0 (2020-10-22)
+-------------------
+* Ability to dump session and restore from file
+* Proxy support
+* Inventory updates
+* Remove market offers
+* Memory and network optimizations
+* Python 3.6 supported
+
 0.20.0 (2020-06-15)
 -------------------
 * Massive restructuring

Makefile

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

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
+

docs/index.html

@@ -93,8 +93,8 @@
                                 <label class="custom-control-label" for="wam">Work as manager</label>
                             </div>
                             <div class="custom-control custom-switch">
-                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="employ">
-                                <label class="custom-control-label" for="employ">Employ employees</label>
+                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="employees">
+                                <label class="custom-control-label" for="employees">Employ employees</label>
                             </div>
                             <div class="custom-control custom-switch">
                                 <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="auto_buy_raw" checked>
@@ -236,8 +236,8 @@
         config.debug = debug.checked;
         let wam = document.getElementById('wam'); // Generated
         config.wam = wam.checked;
-        let employ = document.getElementById('employ'); // Generated
-        config.employ = employ.checked;
+        let employees = document.getElementById('employees'); // Generated
+        config.employees = employees.checked;
 
         let auto_buy_raw = document.getElementById('auto_buy_raw'); // Generated
         let auto_sell_all = document.getElementById('auto_sell_all'); // Generated
@@ -249,7 +249,7 @@
         let auto_sell_house = document.getElementById('auto_sell_house'); // Generated
         let auto_sell_arm = document.getElementById('auto_sell_arm'); // Generated
         let auto_sell_air = document.getElementById('auto_sell_air'); // Generated
-        if (config.wam || config.employ) {
+        if (config.wam || config.employees) {
             auto_buy_raw.disabled = false;
             auto_sell_all.disabled = false;
             auto_sell_frm.disabled = false;
@@ -359,7 +359,7 @@
   "interactive": true,
   "debug": true,
   "wam": true,
-  "employ": true,
+  "employees": true,
   "auto_buy_raw": true,
   "auto_sell_all": true,
   "auto_sell": [

erepublik/__init__.py

@@ -4,9 +4,9 @@
 
 __author__ = """Eriks Karls"""
 __email__ = 'eriks@72.lv'
-__version__ = '0.20.3.10'
+__version__ = '0.23.2.3'
 
 from erepublik import classes, utils, constants
 from erepublik.citizen import Citizen
 
-__all__ = ["classes", "utils", "Citizen", ]
+__all__ = ["classes", "utils", "Citizen", 'constants']

erepublik/access_points.py

@@ -12,32 +12,38 @@ __all__ = ['SlowRequests', 'CitizenAPI']
 
 class SlowRequests(Session):
     last_time: datetime.datetime
-    timeout = datetime.timedelta(milliseconds=500)
-    uas = [
+    timeout: datetime.timedelta = datetime.timedelta(milliseconds=500)
+    uas: List[str] = [
         # Chrome
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36',  # noqa
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36',  # noqa
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',  # noqa
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36',  # noqa
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',  # noqa
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',  # noqa
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',
 
         # FireFox
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:76.0) Gecko/20100101 Firefox/76.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:75.0) Gecko/20100101 Firefox/75.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:73.0) Gecko/20100101 Firefox/73.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:76.0) Gecko/20100101 Firefox/76.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:75.0) Gecko/20100101 Firefox/75.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:74.0) Gecko/20100101 Firefox/74.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:73.0) Gecko/20100101 Firefox/73.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:82.0) Gecko/20100101 Firefox/82.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:81.0) Gecko/20100101 Firefox/81.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:80.0) Gecko/20100101 Firefox/80.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:79.0) Gecko/20100101 Firefox/79.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Firefox/78.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:83.0) Gecko/20100101 Firefox/83.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:82.0) Gecko/20100101 Firefox/82.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:81.0) Gecko/20100101 Firefox/81.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:79.0) Gecko/20100101 Firefox/79.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0',
     ]
-    debug = False
+    debug: bool = False
 
-    def __init__(self):
+    def __init__(self, proxies: Dict[str, str] = None):
         super().__init__()
+        if proxies:
+            self.proxies = proxies
         self.request_log_name = utils.get_file(utils.now().strftime("debug/requests_%Y-%m-%d.log"))
         self.last_time = utils.now()
         self.headers.update({
@@ -81,9 +87,7 @@ class SlowRequests(Session):
 
             body = "[{dt}]\tURL: '{url}'\tMETHOD: {met}\tARGS: {args}\n".format(dt=utils.now().strftime("%F %T"),
                                                                                 url=url, met=method, args=args)
-            utils.get_file(self.request_log_name)
-            with open(self.request_log_name, 'ab') as file:
-                file.write(body.encode("UTF-8"))
+            utils.write_file(self.request_log_name, body)
 
     def _log_response(self, url, resp, redirect: bool = False):
         from erepublik import Citizen
@@ -109,16 +113,18 @@ class SlowRequests(Session):
             filename = 'debug/requests/{time}_{name}{extra}.{ext}'.format(**file_data)
             with open(utils.get_file(filename), 'wb') as f:
                 f.write(resp.text.encode('utf-8'))
+        pass
 
 
 class CitizenBaseAPI:
     url: str = "https://www.erepublik.com/en"
-    _req: SlowRequests = None
-    token: str = ""
+    _req: SlowRequests
+    token: str
 
     def __init__(self):
         """ Class for unifying eRepublik known endpoints and their required/optional parameters """
         self._req = SlowRequests()
+        self.token = ""
 
     def post(self, url: str, data=None, json=None, **kwargs) -> Response:
         return self._req.post(url, data, json, **kwargs)
@@ -129,82 +135,95 @@ class CitizenBaseAPI:
     def _get_main(self) -> Response:
         return self.get(self.url)
 
+    def set_socks_proxy(self, host: str, port: int, username: str = None, password: str = None):
+        url = f'socks5://{username}:{password}@{host}:{port}' if username and password else f'socks5://{host}:{port}'
+        self._req.proxies = dict(http=url, https=url)
+
+    def set_http_proxy(self, host: str, port: int, username: str = None, password: str = None):
+        url = f'http://{username}:{password}@{host}:{port}' if username and password else f'socks5://{host}:{port}'
+        self._req.proxies = dict(http=url)
+
 
 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:
+    def _post_map_rewards_claim(self, node_id: int, extra: bool = False) -> Response:
         data = {'nodeId': node_id, '_token': self.token}
-        return self.post("{}/main/map-rewards-claim".format(self.url), data=data)
+        if extra:
+            data['claimExtra'] = 1
+        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})
+        return self.post(f"{self.url}/main/wheeloffortune-spin", data={'_token': self.token, "_currentCost": cost})
 
     def _post_main_wheel_of_fortune_build(self) -> Response:
-        return self.post(f"{self.url}/wheeloffortune-build", data={'_token': self.token})
+        return self.post(f"{self.url}/main/wheeloffortune-build", data={'_token': self.token})
 
 
 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 _get_main_delete_article(self, article_id: int) -> Response:
+        return self.get(f"{self.url}/main/delete-article/{article_id}/1")
+
+    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 +232,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 +260,177 @@ 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)
+    def _post_economy_marketplace_actions(self, action: str, **kwargs) -> Response:
+        if action == 'buy':
+            data = dict(_token=self.token, offerId=kwargs['offer'], amount=kwargs['amount'],
+                        orderBy="price_asc", currentPage=1, buyAction=1)
+        elif action == 'sell':
+            data = dict(_token=self.token, countryId=kwargs["country_id"], price=kwargs["price"],
+                        industryId=kwargs["industry"], quality=kwargs["quality"], amount=kwargs['amount'],
+                        sellAction='postOffer')
+        elif action == 'delete':
+            data = dict(_token=self.token, offerId=kwargs["offer_id"], sellAction='deleteOffer')
         else:
-            data = dict(_token=self.token, countryId=kwargs["country"], price=kwargs["price"],
-                        industryId=kwargs["industry"], quality=kwargs["quality"], amount=amount, sellAction='postOffer')
-        return self.post("{}/economy/marketplaceActions".format(self.url), data=data)
+            raise ValueError(f"Action '{action}' is not supported! Only 'buy/sell/delete' actions are available")
+        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: # noqa
+        return self.get(f"{self.url}/main/leaderboards-damage-aircraft-rankings/{country_id}/{weeks}/{mu_id}/0")
 
-    def _get_main_leaderboards_damage_rankings(self, country: 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: # noqa
+        return self.get(f"{self.url}/main/leaderboards-damage-rankings/{country_id}/{weeks}/{mu_id}/{div}")
 
-    def _get_main_leaderboards_kills_aircraft_rankings(self, country: 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: # noqa
+        return self.get(f"{self.url}/main/leaderboards-kills-aircraft-rankings/{country_id}/{weeks}/{mu_id}/0")
 
-    def _get_main_leaderboards_kills_rankings(self, country: 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: # noqa
+        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_battle_stats(self, battle_id: int, division: int, division_id: int):
+        return self.get(f"{self.url}/military/battle-stats/{battle_id}/{division}/{division_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_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_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 +439,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,21 +460,28 @@ 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.get(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}")
 
+    def _post_propose_president_candidate(self, party_slug: str, citizen_id: int) -> Response:
+        return self.post(f"{self.url}/propose-president-candidate/{party_slug}",
+                         data=dict(_token=self.token, citizen=citizen_id))
+
+    def _get_auto_propose_president_candidate(self, party_slug: str) -> Response:
+        return self.get(f"{self.url}/auto-propose-president-candidate/{party_slug}")
+
 
 class ErepublikPresidentAPI(CitizenBaseAPI):
     def _post_wars_attack_region(self, war_id: int, region_id: int, region_name: str) -> Response:
@@ -462,50 +491,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:
-        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 +542,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 +605,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 +616,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(

erepublik/classes.py

@@ -1,8 +1,9 @@
 import datetime
 import hashlib
 import threading
+import weakref
 from decimal import Decimal
-from typing import Any, Dict, List, NamedTuple, Optional, Tuple, Union
+from typing import Any, Dict, List, NamedTuple, Tuple, Union, NoReturn, Generator, Iterable
 
 from requests import Response, Session, post
 
@@ -27,26 +28,38 @@ class Holding:
     id: int
     region: int
     companies: List["Company"]
+    name: str
+    _citizen = weakref.ReferenceType
 
-    def __init__(self, _id: int, region: int, citizen):
-        self.citizen = citizen
+    def __init__(self, _id: int, region: int, citizen, name: str = None):
+        self._citizen = weakref.ref(citizen)
         self.id: int = _id
         self.region: int = region
         self.companies: List["Company"] = list()
+        if name:
+            self.name = name
+        else:
+            comp_sum = len(self.companies)
+            name = f"Holding (#{self.id}) with {comp_sum} "
+            if comp_sum == 1:
+                name += "company"
+            else:
+                name += "companies"
+            self.name = name
 
     @property
     def wam_count(self) -> int:
-        return sum([company.wam_enabled and not company.already_worked for company in self.companies])
+        return len([1 for company in self.companies if company.wam_enabled and not company.already_worked])
 
     @property
-    def wam_companies(self) -> List["Company"]:
+    def wam_companies(self) -> Iterable["Company"]:
         return [company for company in self.companies if company.wam_enabled]
 
     @property
-    def employable_companies(self) -> List["Company"]:
+    def employable_companies(self) -> Iterable["Company"]:
         return [company for company in self.companies if company.preset_works]
 
-    def add_company(self, company: "Company"):
+    def add_company(self, company: "Company") -> NoReturn:
         self.companies.append(company)
         self.companies.sort()
 
@@ -60,7 +73,7 @@ class Holding:
                 wrm += company.raw_usage
         return dict(frm=frm, wrm=wrm)
 
-    def get_wam_companies(self, raw_factory: bool = None):
+    def get_wam_companies(self, raw_factory: bool = None) -> List["Company"]:
         raw = []
         factory = []
         for company in self.wam_companies:
@@ -69,18 +82,15 @@ class Holding:
                     raw.append(company)
                 else:
                     factory.append(company)
-        if raw_factory is not None and not raw_factory:
-            return factory
-        elif raw_factory is not None and raw_factory:
-            return raw
-        elif raw_factory is None:
+        if raw_factory is None:
             return raw + factory
         else:
-            raise ErepublikException("raw_factory should be True/False/None")
+            return raw if raw_factory else factory
 
-    def __str__(self):
-        name = f"Holding (#{self.id}) with {len(self.companies)} "
-        if len(self.companies) % 10 == 1:
+    def __str__(self) -> str:
+        comp = len(self.companies)
+        name = f"Holding (#{self.id}) with {comp} "
+        if comp == 1:
             name += "company"
         else:
             name += "companies"
@@ -90,11 +100,17 @@ class Holding:
         return str(self)
 
     @property
-    def as_dict(self):
-        return dict(name=str(self), id=self.id, region=self.region, companies=self.companies, wam_count=self.wam_count)
+    def as_dict(self) -> Dict[str, Union[str, int, List[Dict[str, Union[str, int, bool, float, Decimal]]]]]:
+        return dict(name=self.name, id=self.id, region=self.region,
+                    companies=[c.as_dict for c in self.companies], wam_count=self.wam_count)
+
+    @property
+    def citizen(self):
+        return self._citizen()
 
 
 class Company:
+    _holding: weakref.ReferenceType
     holding: Holding
     id: int
     quality: int
@@ -113,7 +129,7 @@ class Company:
         base_production: Decimal, wam_enabled: bool, can_wam: bool, cannot_wam_reason: str, industry: int,
         already_worked: bool, preset_works: int
     ):
-        self.holding: Holding = holding
+        self._holding = weakref.ref(holding)
         self.id: int = _id
         self.industry: int = industry
         self.quality: int = self._get_real_quality(quality)
@@ -163,7 +179,7 @@ class Company:
 
     @property
     def _sort_keys(self):
-        return not self.is_raw, self._internal_industry, -self.quality, self.id
+        return not self.is_raw, self._internal_industry, self.quality, self.id
 
     def __hash__(self):
         return hash(self._sort_keys)
@@ -196,7 +212,7 @@ class Company:
         return str(self)
 
     @property
-    def as_dict(self):
+    def as_dict(self) -> Dict[str, Union[str, int, bool, float, Decimal]]:
         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,
@@ -211,6 +227,10 @@ class Company:
         # noinspection PyProtectedMember
         return self.holding.citizen._post_economy_upgrade_company(self.id, level, self.holding.citizen.details.pin)
 
+    @property
+    def holding(self) -> Holding:
+        return self._holding()
+
 
 class MyCompanies:
     work_units: int = 0
@@ -218,13 +238,14 @@ class MyCompanies:
     ff_lockdown: int = 0
 
     holdings: Dict[int, Holding]
-    companies: List[Company]
+    _companies: weakref.WeakSet
+    _citizen: weakref.ReferenceType
+    companies: Generator[Company, None, None]
 
     def __init__(self, citizen):
-        from erepublik import Citizen
-        self.citizen: Citizen = citizen
-        self.holdings: Dict[int, Holding] = dict()
-        self.companies: List[Company] = list()
+        self._citizen = weakref.ref(citizen)
+        self.holdings = dict()
+        self._companies = weakref.WeakSet()
         self.next_ot_time = utils.now()
 
     def prepare_holdings(self, holdings: Dict[str, Dict[str, Any]]):
@@ -233,10 +254,11 @@ class MyCompanies:
         """
         for holding in holdings.values():
             if holding.get('id') not in self.holdings:
-                self.holdings.update(
-                    {int(holding.get('id')): Holding(holding['id'], holding['region_id'], self.citizen)})
+                self.holdings.update({
+                    int(holding.get('id')): Holding(holding['id'], holding['region_id'], self.citizen, holding['name'])
+                })
         if not self.holdings.get(0):
-            self.holdings.update({0: Holding(0, 0, self.citizen)})  # unassigned
+            self.holdings.update({0: Holding(0, 0, self.citizen, 'Unassigned')})  # unassigned
 
     def prepare_companies(self, companies: Dict[str, Dict[str, Any]]):
         """
@@ -258,7 +280,7 @@ class MyCompanies:
                 company_dict.get('can_work_as_manager'), company_dict.get('cannot_work_as_manager_reason'),
                 company_dict.get('industry_id'), company_dict.get('already_worked'), company_dict.get('preset_works')
             )
-            self.companies.append(company)
+            self._companies.add(company)
             holding.add_company(company)
 
     def get_employable_factories(self) -> Dict[int, int]:
@@ -268,27 +290,41 @@ class MyCompanies:
         return sum([holding.wam_count for holding in self.holdings.values()])
 
     @staticmethod
-    def get_needed_inventory_usage(companies: Union[Company, List[Company]]) -> Decimal:
+    def get_needed_inventory_usage(companies: Union[Company, Iterable[Company]]) -> Decimal:
         if isinstance(companies, list):
-            return sum([company.products_made * 100 if company.is_raw else 1 for company in companies])
+            return sum(company.products_made * 100 if company.is_raw else 1 for company in companies)
         else:
             return companies.products_made
 
+    @property
+    def companies(self) -> Generator[Company, None, None]:
+        return (c for c in self._companies)
+
     def __str__(self):
-        return f"MyCompanies: {len(self.companies)} companies in {len(self.holdings)} holdings"
+        return f"MyCompanies: {sum(1 for _ in self.companies)} companies in {len(self.holdings)} holdings"
 
     def __repr__(self):
         return str(self)
 
     def __clear_data(self):
         for holding in self.holdings.values():
+            for company in holding.companies:  # noqa
+                del company
             holding.companies.clear()
-        self.companies.clear()
+        self._companies.clear()
 
     @property
-    def as_dict(self):
+    def as_dict(self) -> Dict[str, Union[str, int, datetime.datetime, Dict[str, Dict[str, Union[
+        str, int, List[Dict[str, Union[str, int, bool, float, Decimal]]]]
+    ]]]]:
         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))
+                    ff_lockdown=self.ff_lockdown,
+                    holdings={str(hi): h.as_dict for hi, h in self.holdings.items()},
+                    company_count=sum(1 for _ in self.companies))
+
+    @property
+    def citizen(self):
+        return self._citizen()
 
 
 class Config:
@@ -321,6 +357,8 @@ class Config:
     telegram = True
     telegram_chat_id = 0
     telegram_token = ""
+    maverick = False
+    spin_wheel_of_fortune = False
 
     def __init__(self):
         self.auto_sell = []
@@ -353,6 +391,8 @@ class Config:
         self.telegram = True
         self.telegram_chat_id = 0
         self.telegram_token = ""
+        self.maverick = False
+        self.spin_wheel_of_fortune = False
 
     @property
     def as_dict(self):
@@ -361,10 +401,11 @@ class Config:
                     fight=self.fight, air=self.air, ground=self.ground, all_in=self.all_in,
                     next_energy=self.next_energy, boosters=self.boosters, travel_to_fight=self.travel_to_fight,
                     always_travel=self.always_travel, epic_hunt=self.epic_hunt, epic_hunt_ebs=self.epic_hunt_ebs,
-                    rw_def_side=self.rw_def_side, interactive=self.interactive,
+                    rw_def_side=self.rw_def_side, interactive=self.interactive, maverick=self.maverick,
                     continuous_fighting=self.continuous_fighting, auto_buy_raw=self.auto_buy_raw,
                     force_wam=self.force_wam, sort_battles_time=self.sort_battles_time, force_travel=self.force_travel,
-                    telegram=self.telegram, telegram_chat_id=self.telegram_chat_id, telegram_token=self.telegram_token)
+                    telegram=self.telegram, telegram_chat_id=self.telegram_chat_id, telegram_token=self.telegram_token,
+                    spin_wheel_of_fortune=self.spin_wheel_of_fortune)
 
 
 class Energy:
@@ -420,24 +461,25 @@ class Energy:
 
 
 class Details:
-    xp = 0
-    cc = 0
-    pp = 0
-    pin = None
-    gold = 0
+    xp: int = 0
+    cc: float = 0
+    pp: int = 0
+    pin: str = None
+    gold: float = 0
     next_pp: List[int] = None
-    citizen_id = 0
+    citizen_id: int = 0
     citizenship: constants.Country
-    current_region = 0
+    current_region: int = 0
     current_country: constants.Country
-    residence_region = 0
+    residence_region: int = 0
     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, }
+    daily_task_done: bool = False
+    daily_task_reward: bool = False
+    mayhem_skills: Dict[int, int]
 
     def __init__(self):
         self.next_pp = []
+        self.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}
 
     @property
     def xp_till_level_up(self):
@@ -528,10 +570,13 @@ class Reporter:
                     queue=self.__to_update)
 
     def __init__(self, citizen):
-        self.citizen = citizen
+        self._citizen = weakref.ref(citizen)
         self._req = Session()
         self.url = "https://api.erep.lv"
-        self._req.headers.update({"user-agent": "Bot reporter v2"})
+        self._req.headers.update({"user-agent": "eRepublik Script Reporter v3",
+                                  'erep-version': utils.__version__,
+                                  'erep-user-id': str(self.citizen_id),
+                                  'erep-user-name': self.citizen.name})
         self.__to_update = []
         self.__registered: bool = False
 
@@ -541,6 +586,10 @@ class Reporter:
         self.register_account()
         self.allowed = True
 
+    @property
+    def citizen(self):
+        return self._citizen()
+
     def __update_key(self):
         self.key = hashlib.md5(bytes(f"{self.name}:{self.email}", encoding="UTF-8")).hexdigest()
 
@@ -548,10 +597,10 @@ class Reporter:
         if self.__to_update:
             for unreported_data in self.__to_update:
                 unreported_data.update(player_id=self.citizen_id, key=self.key)
-                unreported_data = utils.json.load(utils.json.dumps(unreported_data, cls=MyJSONEncoder, sort_keys=True))
+                unreported_data = utils.json.loads(utils.json.dumps(unreported_data, cls=MyJSONEncoder))
                 self._req.post("{}/bot/update".format(self.url), json=unreported_data)
             self.__to_update.clear()
-        data = utils.json.loads(utils.json.dumps(data, cls=MyJSONEncoder, sort_keys=True))
+        data = utils.json.loads(utils.json.dumps(data, cls=MyJSONEncoder))
         r = self._req.post("{}/bot/update".format(self.url), json=data)
         return r
 
@@ -593,6 +642,12 @@ class Reporter:
         else:
             self.__to_update.append(json_data)
 
+    def report_fighting(self, battle: "Battle", invader: bool, division: "BattleDivision", damage: float, hits: int):
+        side = battle.invader if invader else battle.defender
+        self.report_action('FIGHT', dict(battle_id=battle.id, side=side, dmg=damage,
+                                         air=battle.has_air, hits=hits,
+                                         round=battle.zone_id, extra=dict(battle=battle, side=side, division=division)))
+
     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))
 
@@ -604,13 +659,13 @@ class Reporter:
         except:  # noqa
             return []
 
-    def fetch_tasks(self) -> Optional[Tuple[str, Tuple[Any]]]:
+    def fetch_tasks(self) -> List[Union[str, Tuple[Any]]]:
         try:
             task_response = self._req.get(f'{self.url}/api/v1/command',
                                           params=dict(citizen=self.citizen_id, key=self.key))
             return task_response.json().get('task_collection')
         except:  # noqa
-            return
+            return []
 
 
 class MyJSONEncoder(utils.json.JSONEncoder):
@@ -645,37 +700,42 @@ class BattleSide:
     deployed: List[constants.Country]
     allies: List[constants.Country]
     battle: "Battle"
+    _battle: weakref.ReferenceType
     country: constants.Country
-    defender: bool
+    is_defender: bool
 
     def __init__(self, battle: "Battle", country: constants.Country, points: int, allies: List[constants.Country],
                  deployed: List[constants.Country], defender: bool):
-        self.battle = battle
+        self._battle = weakref.ref(battle)
         self.country = country
         self.points = points
         self.allies = allies
         self.deployed = deployed
-        self.defender = defender
+        self.is_defender = defender
 
     @property
     def id(self) -> int:
         return self.country.id
 
     def __repr__(self):
-        side_text = "Defender" if self.defender else "Invader "
-        return f"<BattleSide: {side_text} {self.country.name}|{self.points:02d}p>"
+        side_text = "Defender" if self.is_defender else "Invader "
+        return f"<BattleSide: {side_text} {self.country.name}|{self.points:>2d}p>"
 
     def __str__(self):
-        side_text = "Defender" if self.defender else "Invader "
-        return f"{side_text} {self.country.name} - {self.points:02d} points"
+        side_text = "Defender" if self.is_defender else "Invader "
+        return f"{side_text} {self.country.name} - {self.points:>2d} points"
 
     def __format__(self, format_spec):
         return self.country.iso
 
     @property
     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))
+        return dict(points=self.points, country=self.country, is_defender=self.is_defender, allies=self.allies,
+                    deployed=self.deployed)
+
+    @property
+    def battle(self):
+        return self._battle()
 
 
 class BattleDivision:
@@ -689,11 +749,12 @@ class BattleDivision:
     terrain: int
     div: int
     battle: "Battle"
+    _battle: weakref.ReferenceType
 
     @property
     def as_dict(self):
         return dict(id=self.id, division=self.div, terrain=(self.terrain, self.terrain_display), wall=self.wall,
-                    epic=self.epic, battle=str(self.battle), end=self.div_end)
+                    epic=self.epic, end=self.div_end)
 
     @property
     def is_air(self):
@@ -715,7 +776,7 @@ class BattleDivision:
         :type wall_for: int
         :type wall_dom: float
         """
-        self.battle = battle
+        self._battle = weakref.ref(battle)
         self.id = div_id
         self.end = end
         self.epic = epic
@@ -728,7 +789,7 @@ class BattleDivision:
         return constants.TERRAINS[self.terrain]
 
     def __str__(self):
-        base_name = f"Div #{self.id} d{self.div}"
+        base_name = f"D{self.div} #{self.id}"
         if self.terrain:
             base_name += f" ({self.terrain_display})"
         if self.div_end:
@@ -738,6 +799,10 @@ class BattleDivision:
     def __repr__(self):
         return f"<BattleDivision #{self.id} (battle #{self.battle.id})>"
 
+    @property
+    def battle(self):
+        return self._battle()
+
 
 class Battle:
     id: int
@@ -756,7 +821,7 @@ class Battle:
     def as_dict(self):
         return dict(id=self.id, war_id=self.war_id, divisions=self.div, zone=self.zone_id, rw=self.is_rw,
                     dict_lib=self.is_dict_lib, start=self.start, sides={'inv': self.invader, 'def': self.defender},
-                    region=[self.region_id, self.region_name])
+                    region=[self.region_id, self.region_name], link=self.link)
 
     @property
     def has_air(self) -> bool:
@@ -765,6 +830,10 @@ class Battle:
                 return True
         return not bool(self.zone_id % 4)
 
+    @property
+    def has_started(self) -> bool:
+        return self.start <= utils.now()
+
     @property
     def has_ground(self) -> bool:
         for div in self.div.values():
@@ -795,13 +864,15 @@ class Battle:
         self.invader = BattleSide(
             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
+            [constants.COUNTRIES[row.get('id')] for row in battle.get('inv', {}).get('ally_list') if row['deployed']],
+            False
         )
 
         self.defender = BattleSide(
             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
+            [constants.COUNTRIES[row.get('id')] for row in battle.get('def', {}).get('ally_list') if row['deployed']],
+            True
         )
 
         self.div = {}
@@ -810,7 +881,7 @@ class Battle:
             if data.get('end'):
                 end = datetime.datetime.fromtimestamp(data.get('end'), tz=constants.erep_tz)
             else:
-                end = utils.localize_dt(datetime.datetime.max - datetime.timedelta(days=1))
+                end = constants.max_datetime
 
             battle_div = BattleDivision(self, div_id=data.get('id'), div=data.get('div'), end=end,
                                         epic=data.get('epic_type') in [1, 5],
@@ -828,7 +899,8 @@ class Battle:
         else:
             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}"
+        return (f"Battle {self.id} for {self.region_name[:16]:16} | "
+                f"{self.invader} : {self.defender} | Round time {time_part} | {'R'+str(self.zone_id):>3}")
 
     def __repr__(self):
         return f"<Battle #{self.id} {self.invader}:{self.defender} R{self.zone_id}>"
@@ -888,7 +960,7 @@ class TelegramBot:
     def as_dict(self):
         return {'chat_id': self.chat_id, 'api_url': self.api_url, 'player': self.player_name,
                 'last_time': self._last_time, 'next_time': self._next_time, 'queue': self.__queue,
-                'initialized': self.__initialized, 'has_threads': bool(len(self._threads))}
+                'initialized': self.__initialized, 'has_threads': not self._threads}
 
     def do_init(self, chat_id: int, token: str, player_name: str = ""):
         self.chat_id = chat_id

erepublik/constants.py

@@ -1,10 +1,14 @@
+import datetime
 from typing import Dict, Optional, Union
 
 import pytz
 
-__all__ = ["erep_tz", "Country", "AIR_RANKS", "COUNTRIES", "FOOD_ENERGY", "GROUND_RANKS", "GROUND_RANK_POINTS", "INDUSTRIES", "TERRAINS"]
+__all__ = ["erep_tz", 'min_datetime', "max_datetime", "Country", "AIR_RANKS", "COUNTRIES", "FOOD_ENERGY",
+           "GROUND_RANKS", "GROUND_RANK_POINTS", "INDUSTRIES", "TERRAINS"]
 
 erep_tz = pytz.timezone('US/Pacific')
+min_datetime = erep_tz.localize(datetime.datetime(2007, 11, 20))
+max_datetime = erep_tz.localize(datetime.datetime(2281, 9, 4))
 
 
 class Country:
@@ -19,6 +23,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}')"
 
@@ -46,17 +53,17 @@ class Country:
 
 
 class Industries:
-    __by_name = {'food': 1, 'weapons': 2, 'house': 4, 'aircraft': 23,
-                 'foodRaw': 7, 'weaponsRaw': 12, 'houseRaw': 18, 'aircraftRaw': 24,
+    __by_name = {'food': 1, 'weapon': 2, 'ticket': 3, 'house': 4, 'aircraft': 23,
+                 'foodraw': 7, 'weaponraw': 12, 'houseraw': 18, 'aircraftraw': 24, 'airplaneraw': 24,
                  'frm': 7, 'wrm': 12, 'hrm': 18, 'arm': 24,
                  'frm q1': 7, 'frm q2': 8, 'frm q3': 9, 'frm q4': 10, 'frm q5': 11,
                  'wrm q1': 12, 'wrm q2': 13, 'wrm q3': 14, 'wrm q4': 15, 'wrm q5': 16,
                  'hrm q1': 18, 'hrm q2': 19, 'hrm q3': 20, 'hrm q4': 21, 'hrm q5': 22,
                  'arm q1': 24, 'arm q2': 25, 'arm q3': 26, 'arm q4': 27, 'arm q5': 28}
-    __by_id = {1: "Food", 2: "Weapons", 4: "House", 23: "Aircraft",
+    __by_id = {1: "Food", 2: "Weapon", 3: "Ticket", 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",
+               12: "weaponRaw", 13: "WRM q2", 14: "WRM q3", 15: "WRM q4", 16: "WRM q5",
+               17: "houseRaw", 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]]:
@@ -110,7 +117,7 @@ COUNTRIES: Dict[int, Country] = {
     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'),
+    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'),

erepublik/utils.py

@@ -7,9 +7,10 @@ import textwrap
 import time
 import traceback
 import unicodedata
+import warnings
 from decimal import Decimal
 from pathlib import Path
-from typing import Any, List, Mapping, Optional, Union
+from typing import Any, List, Optional, Union, Dict
 
 import requests
 
@@ -26,8 +27,8 @@ __all__ = ['VERSION', 'calculate_hit', 'caught_error', 'date_from_eday', 'eday_f
            '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'
+if not sys.version_info >= (3, 6):
+    raise AssertionError('This script requires Python version 3.6 and higher\n'
                          'But Your version is v{}.{}.{}'.format(*sys.version_info))
 
 VERSION: str = __version__
@@ -42,13 +43,12 @@ def localize_timestamp(timestamp: int) -> datetime.datetime:
 
 
 def localize_dt(dt: Union[datetime.date, datetime.datetime]) -> datetime.datetime:
-    try:
-        try:
-            return constants.erep_tz.localize(dt)
-        except AttributeError:
-            return constants.erep_tz.localize(datetime.datetime.combine(dt, datetime.time(0, 0, 0)))
-    except ValueError:
-        return dt.astimezone(constants.erep_tz)
+    if isinstance(dt, datetime.datetime):
+        return constants.erep_tz.localize(dt)
+    elif isinstance(dt, datetime.date):
+        return constants.erep_tz.localize(datetime.datetime.combine(dt, datetime.time(0, 0, 0)))
+    else:
+        raise TypeError(f"Argument dt must be and instance of datetime.datetime or datetime.date not {type(dt)}")
 
 
 def good_timedelta(dt: datetime.datetime, td: datetime.timedelta) -> datetime.datetime:
@@ -116,10 +116,12 @@ def _write_log(msg, timestamp: bool = True, should_print: bool = False):
 
 
 def write_interactive_log(*args, **kwargs):
+    kwargs.pop("should_print", None)
     _write_log(should_print=True, *args, **kwargs)
 
 
 def write_silent_log(*args, **kwargs):
+    kwargs.pop("should_print", None)
     _write_log(should_print=False, *args, **kwargs)
 
 
@@ -150,7 +152,8 @@ def get_file(filepath: str) -> str:
 def write_file(filename: str, content: str) -> int:
     filename = get_file(filename)
     with open(filename, 'ab') as f:
-        return f.write(content.encode("utf-8"))
+        ret = f.write(content.encode("utf-8"))
+    return ret
 
 
 def write_request(response: requests.Response, is_error: bool = False):
@@ -177,14 +180,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",
@@ -220,8 +223,16 @@ 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),
+        files.append(('file', ("local_vars.json", json.dumps(local_vars, cls=MyJSONEncoder),
                                "application/json")))
     if isinstance(player, Citizen):
         files.append(('file', ("instance.json", player.to_json(indent=True), "application/json")))
@@ -270,15 +281,15 @@ def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commi
         write_silent_log(log_info)
     trace = inspect.trace()
     if trace:
-        trace = trace[-1][0].f_locals
-        if trace.get('__name__') == '__main__':
-            trace = {'commit_id': trace.get('COMMIT_ID'),
-                     'interactive': trace.get('INTERACTIVE'),
-                     'version': trace.get('__version__'),
-                     'config': trace.get('CONFIG')}
+        local_vars = trace[-1][0].f_locals
+        if local_vars.get('__name__') == '__main__':
+            local_vars.update({'commit_id': local_vars.get('COMMIT_ID'),
+                               'interactive': local_vars.get('INTERACTIVE'),
+                               'version': local_vars.get('__version__'),
+                               'config': local_vars.get('CONFIG')})
     else:
-        trace = dict()
-    send_email(name, content, citizen, local_vars=trace)
+        local_vars = dict()
+    send_email(name, content, citizen, local_vars=local_vars)
 
 
 def process_warning(log_info: str, name: str, exc_info: tuple, citizen=None, commit_id: str = None):
@@ -298,10 +309,10 @@ def process_warning(log_info: str, name: str, exc_info: tuple, citizen=None, com
 
     trace = inspect.trace()
     if trace:
-        trace = trace[-1][0].f_locals
+        local_vars = trace[-1][0].f_locals
     else:
-        trace = dict()
-    send_email(name, content, citizen, local_vars=trace)
+        local_vars = dict()
+    send_email(name, content, citizen, local_vars=local_vars)
 
 
 def slugify(value, allow_unicode=False) -> str:
@@ -328,17 +339,8 @@ def calculate_hit(strength: float, rang: int, tp: bool, elite: bool, ne: bool, b
     base_wpn = (1 + Decimal(str(weapon / 100)))
     dmg = 10 * base_str * base_rnk * base_wpn
 
-    if elite:
-        dmg = dmg * 11 / 10
-
-    if tp and rang >= 70:
-        dmg = dmg * (1 + Decimal((rang - 69) / 10))
-
-    dmg = dmg * (100 + booster) / 100
-
-    if ne:
-        dmg = dmg * 11 / 10
-    return round(dmg, dec)
+    dmg = get_final_hit_dmg(dmg, rang, tp=tp, elite=elite, ne=ne, booster=booster)
+    return Decimal(round(dmg, dec))
 
 
 def get_ground_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_patriot: bool = False,
@@ -359,3 +361,42 @@ def get_air_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_pat
     rang = r['military']['militaryData']['aircraft']['rankNumber']
     elite = r['citizenAttributes']['level'] > 100
     return calculate_hit(0, rang, true_patriot, elite, natural_enemy, booster, weapon_power)
+
+
+def get_final_hit_dmg(base_dmg: Union[Decimal, float, str], rang: int,
+                      tp: bool = False, elite: bool = False, ne: bool = False, booster: int = 0) -> Decimal:
+    dmg = Decimal(str(base_dmg))
+
+    if elite:
+        dmg = dmg * 11 / 10
+    if tp and rang >= 70:
+        dmg = dmg * (1 + Decimal((rang - 69) / 10))
+    dmg = dmg * (100 + booster) / 100
+    if ne:
+        dmg = dmg * 11 / 10
+    return Decimal(dmg)
+
+# def _clear_up_battle_memory(battle):
+#     del battle.invader._battle, battle.defender._battle
+#     for div_id, division in battle.div.items():
+#         del division._battle
+
+
+def deprecation(message):
+    warnings.warn(message, DeprecationWarning, stacklevel=2)
+
+
+def wait_for_lock(function):
+    def wrapper(instance, *args, **kwargs):
+        if not instance.concurrency_available.wait(600):
+            e = 'Concurrency not freed in 10min!'
+            instance.write_log(e)
+            if instance.debug:
+                instance.report_error(e)
+            return None
+        else:
+            instance.concurrency_available.clear()
+            ret = function(instance, *args, **kwargs)
+            instance.concurrency_available.set()
+            return ret
+    return wrapper

examples/battle_launcher.py

@@ -29,7 +29,7 @@ def _battle_launcher(player: Citizen):
     """
     global CONFIG
     finished_war_ids = {*[]}
-    war_data = CONFIG.get('start_battles', {})
+    war_data = CONFIG.get('battle_launcher', {})
     war_ids = {int(war_id) for war_id in war_data.keys()}
     next_attack_time = player.now
     next_attack_time = next_attack_time.replace(minute=next_attack_time.minute // 5 * 5, second=0)
@@ -45,7 +45,7 @@ def _battle_launcher(player: Citizen):
 
                 status = player.get_war_status(war_id)
                 if status.get('ended', False):
-                    CONFIG['start_battles'].pop(war_id, None)
+                    CONFIG['battle_launcher'].pop(war_id, None)
                     finished_war_ids.add(war_id)
                     continue
                 elif not status.get('can_attack'):
@@ -64,7 +64,15 @@ def _battle_launcher(player: Citizen):
                                     player.update_war_info()
                                     battle_id = player.get_war_status(war_id).get("battle_id")
                                     if battle_id is not None and battle_id in player.all_battles:
-                                        player.fight(battle_id, player.details.citizenship, hits)
+                                        battle = player.all_battles.get(battle_id)
+                                        for division in battle.div.values():
+                                            if division.div == player.division:
+                                                div = division
+                                                break
+                                        else:
+                                            player.report_error("Players division not found in the first round!")
+                                            break
+                                        player.fight(battle, div, battle.invader, hits)
                                         break
                                     player.sleep(1)
                         if attacked:

examples/eat_work_train.py

@@ -1,12 +1,16 @@
 from datetime import timedelta
 
-from erepublik import Citizen, utils
+from erepublik import Citizen, utils, constants
 
 CONFIG = {
     'email': 'player@email.com',
     'password': 'Pa$5w0rd!',
     'interactive': True,
-    'debug': True
+    'debug': True,
+    'work': True,
+    'ot': True,  # Work OverTime
+    'wam': True,  # WorkAsManager
+    'train': True
 }
 
 
@@ -14,11 +18,14 @@ CONFIG = {
 def main():
     player = Citizen(email=CONFIG['email'], password=CONFIG['password'], auto_login=False)
     player.config.interactive = CONFIG['interactive']
-    player.config.fight = CONFIG['fight']
+    player.config.work = CONFIG['work']
+    player.config.train = CONFIG['train']
+    player.config.ot = CONFIG['ot']
+    player.config.wam = CONFIG['wam']
     player.set_debug(CONFIG.get('debug', False))
     player.login()
     now = player.now.replace(second=0, microsecond=0)
-    dt_max = now.replace(year=9999)
+    dt_max = constants.max_datetime
     tasks = {
         'eat': now,
     }
@@ -76,7 +83,7 @@ def main():
                 tasks.update({'eat': next_time})
 
             if tasks.get('ot', dt_max) <= now:
-                player.write_log("Doing task: ot")
+                player.write_log("Doing task: work overtime")
                 if now > player.my_companies.next_ot_time:
                     player.work_ot()
                     next_time = now + timedelta(minutes=60)

requirements_dev.txt

@@ -1,17 +1,19 @@
-bump2version==1.0.0
-coverage==5.1
+bump2version==1.0.1
+coverage==5.3
 edx-sphinx-theme==1.5.0
-flake8==3.8.3
-ipython==7.15.0
-isort==4.3.21
-pip==20.1.1
-PyInstaller==3.6
-pytz==2020.1
-requests==2.23.0
-responses==0.10.15
-setuptools==47.1.1
-Sphinx==3.1.1
-tox==3.15.2
-twine==3.1.1
-watchdog==0.10.2
-wheel==0.34.2
+flake8==3.8.4
+ipython>=7.19.0
+isort==5.6.4
+pip==20.3
+PyInstaller==4.1
+pytz==2020.4
+pytest==6.1.2
+responses==0.12.1
+setuptools==50.3.2
+Sphinx==3.3.1
+requests==2.25.0
+PySocks==1.7.1
+tox==3.20.1
+twine==3.2.0
+watchdog==0.10.4
+wheel==0.35.1

setup.cfg

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

setup.py

@@ -11,11 +11,18 @@ 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.4',
+    'requests==2.25.0',
+    'PySocks==1.7.1'
+]
 
 setup_requirements = []
 
-test_requirements = []
+test_requirements = [
+    "pytest==6.1.2",
+    "responses==0.12.1"
+]
 
 setup(
     author="Eriks Karls",
@@ -38,11 +45,11 @@ setup(
     keywords='erepublik',
     name='eRepublik',
     packages=find_packages(include=['erepublik']),
-    python_requires='>=3.7, <4',
+    python_requires='>=3.6, <4',
     setup_requires=setup_requirements,
     test_suite='tests',
     tests_require=test_requirements,
     url='https://github.com/eeriks/erepublik/',
-    version='0.20.3.10',
+    version='0.23.2.3',
     zip_safe=False,
 )

tests/test_erepublik_script.py

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

tox.ini

@@ -1,9 +1,10 @@
 [tox]
-envlist =  py37, flake8
+envlist = py37, py38, flake8
 
 [travis]
 python =
     3.7: py37
+    3.8: py38
 
 [testenv:flake8]
 basepython = python
@@ -15,4 +16,3 @@ setenv =
     PYTHONPATH = {toxinidir}
 
 commands = python setup.py test
-