Bump version: 0.23.4.12 → 0.23.4.13

Explicitly updated all Citizen*.as_dict properties

.gitignore

@@ -102,5 +102,4 @@ ENV/
 
 debug/
 log/
-docs/
 *dump.json

.pre-commit-config.yaml

@@ -0,0 +1,13 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.2.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: check-added-large-files
+
+default_language_version:
+    python: python3.7

HISTORY.rst

@@ -2,6 +2,25 @@
 History
 =======
 
+0.23.4 (2021-01-05)
+-------------------
+* Added expiration data to inventory items
+* Inventory is now based on `classes.Inventory`
+* Requirement update to make them more flexible regarding versions required
+* Restructured inventory
+
+0.23.3 (2020-12-17)
+-------------------
+* Fixed carpet bombing
+* Fixed hits done amount when fighting on ground
+* Minor requirement updates
+* Minor tweaks to method signatures
+* Fixed buy food if unable to work or train because not enough energy and not enough food
+* Fixed applications for party presidency and congress if not a party member
+* Removed tox
+* Updates to github.io config generator
+* Fixed `Citizen.concurrency_available` stuck in unset state if exception is being raised while doing concurrency task
+
 0.23.2 (2020-12-01)
 -------------------
 * Added concurrency checks to guard against simultaneous fighting/wam'ing/traveling
@@ -17,7 +36,7 @@ History
 
 0.23.0 (2020-11-26)
 -------------------
-* ***0.23 - last supported version for Python 3.7.***
+* ***0.23 - last officially 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

LICENSE

@@ -19,4 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-

Makefile

@@ -76,7 +76,6 @@ servedocs: docs ## compile the docs watching for changes
 
 release: dist ## package and upload a release
 	twine upload dist/*
-	clean
 
 dist: clean ## builds source and wheel package
 	python setup.py sdist

README.rst

@@ -34,4 +34,3 @@ 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/erepublik.rst

@@ -0,0 +1,61 @@
+erepublik package
+=================
+
+Submodules
+----------
+
+erepublik.access\_points module
+-------------------------------
+
+.. automodule:: erepublik.access_points
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+erepublik.citizen module
+------------------------
+
+.. automodule:: erepublik.citizen
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+erepublik.classes module
+------------------------
+
+.. automodule:: erepublik.classes
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+erepublik.constants module
+--------------------------
+
+.. automodule:: erepublik.constants
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+erepublik.types module
+----------------------
+
+.. automodule:: erepublik.types
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+erepublik.utils module
+----------------------
+
+.. automodule:: erepublik.utils
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Module contents
+---------------
+
+.. automodule:: erepublik
+   :members:
+   :undoc-members:
+   :show-inheritance:

docs/index.html

@@ -393,7 +393,7 @@
         }
 
         config.air = air.checked;
-        config.ground = ground.cehcked;
+        config.ground = ground.checked;
         config.boosters = boosters.checked;
         config.continuous_fighting = continuous_fighting.checked;
         config.next_energy = next_energy.checked;
@@ -402,10 +402,9 @@
         config.travel_to_fight = travel_to_fight.checked;
         config.epic_hunt = epic_hunt.checked;
         config.epic_hunt_ebs = config.epic_hunt ? epic_hunt_ebs.checked : config.epic_hunt;
+        config.maverick = false;
 
         // Advanced
-
-
         let telegram = document.getElementById('telegram'); // Generated
         config.telegram = telegram.checked;
         let telegram_chat_id = document.getElementById('telegram_chat_id'); // Generated

docs/modules.rst

@@ -0,0 +1,7 @@
+erepublik
+=========
+
+.. toctree::
+   :maxdepth: 4
+
+   erepublik

docs/usage.rst

@@ -7,4 +7,3 @@ To use eRepublik script in a project::
     from erepublik import Citizen
     player = Citizen('email@domain.com', 'password')
     player.update_all()
-

erepublik/__init__.py

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

erepublik/access_points.py

@@ -13,43 +13,43 @@ __all__ = ['SlowRequests', 'CitizenAPI']
 class SlowRequests(Session):
     last_time: datetime.datetime
     timeout: datetime.timedelta = datetime.timedelta(milliseconds=500)
-    uas: List[str] = [
+    _uas: List[str] = [
         # Chrome
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36',
 
         # FireFox
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:84.0) Gecko/20100101 Firefox/84.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 (X11; Linux x86_64; rv:84.0) Gecko/20100101 Firefox/84.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',
     ]
     debug: bool = False
 
-    def __init__(self, proxies: Dict[str, str] = None):
+    def __init__(self, proxies: Dict[str, str] = None, user_agent: str = None):
         super().__init__()
         if proxies:
             self.proxies = proxies
+        if user_agent is None:
+            user_agent = random.choice(self._uas)
         self.request_log_name = utils.get_file(utils.now().strftime("debug/requests_%Y-%m-%d.log"))
         self.last_time = utils.now()
-        self.headers.update({
+        self.headers.update({'User-Agent': user_agent})
-            'User-Agent': random.choice(self.uas)
-        })
 
     @property
     def as_dict(self):
-        return dict(last_time=self.last_time, timeout=self.timeout, user_agent=self.headers['User-Agent'],
+        return dict(last_time=self.last_time, timeout=self.timeout, cookies=self.cookies.get_dict(), debug=self.debug,
-                    request_log_name=self.request_log_name, debug=self.debug)
+                    user_agent=self.headers['User-Agent'], request_log_name=self.request_log_name, proxies=self.proxies)
 
     def request(self, method, url, *args, **kwargs):
         self._slow_down_requests()
@@ -120,6 +120,10 @@ class CitizenBaseAPI:
         self._req = SlowRequests()
         self.token = ""
 
+    @property
+    def as_dict(self):
+        return dict(url=self.url, request=self._req.as_dict, token=self.token)
+
     def post(self, url: str, data=None, json=None, **kwargs) -> Response:
         return self._req.post(url, data, json, **kwargs)
 
@@ -305,11 +309,11 @@ class ErepublikEconomyAPI(CitizenBaseAPI):
         return self.post(f"{self.url}/main/buyGoldItems", data=data)
 
     def _post_economy_activate_booster(self, quality: int, duration: int, kind: str) -> Response:
-        data = dict(type=kind, quality=quality, duration=duration, fromInventory=True)
+        data = dict(type=kind, quality=quality, duration=duration, fromInventory=True, _token=self.token)
         return self.post(f"{self.url}/economy/activateBooster", data=data)
 
     def _post_economy_activate_house(self, quality: int) -> Response:
-        data = {"action": "activate", "quality": quality, "type": "house", "_token": self.token}
+        data = dict(action="activate", quality=quality, type="house", _token=self.token)
         return self.post(f"{self.url}/economy/activateHouse", data=data)
 
     def _post_economy_donate_items_action(self, citizen_id: int, amount: int, industry: int,
@@ -595,6 +599,10 @@ class ErepublikProfileAPI(CitizenBaseAPI):
         data = dict(_token=self.token, rewardId=reward_id)
         return self.post(f"{self.url}/main/weekly-challenge-collect-reward", data=data)
 
+    def _post_main_weekly_challenge_collect_all(self, max_reward_id: int) -> Response:
+        data = dict(_token=self.token, maxRewardId=max_reward_id)
+        return self.post(f"{self.url}/main/weekly-challenge-collect-all", data=data)
+
     def _post_main_profile_update(self, action: str, params: str):
         data = {"action": action, "params": params, "_token": self.token}
         return self.post(f"{self.url}/main/profile-update", data=data)

erepublik/citizen.py

@@ -2,7 +2,7 @@ import re
 import sys
 import warnings
 import weakref
-from datetime import datetime, timedelta
+from datetime import datetime, time, timedelta
 from decimal import Decimal
 from itertools import product
 from threading import Event
@@ -11,7 +11,8 @@ from typing import Any, Dict, List, NoReturn, Optional, Set, Tuple, Union
 
 from requests import HTTPError, RequestException, Response
 
-from . import access_points, classes, constants, utils
+from . import access_points, classes, constants, types, utils
+from .access_points import SlowRequests
 from .classes import OfferItem
 
 
@@ -20,9 +21,7 @@ class BaseCitizen(access_points.CitizenAPI):
     _last_inventory_update: datetime = constants.min_datetime
 
     promos: Dict[str, datetime] = None
-    inventory: Dict[str, Dict[str, Dict[int, Dict[str, Union[str, int, float]]]]]
+    _inventory: classes.Inventory
-    inventory_status: Dict[str, int]
-    boosters: Dict[int, Dict[int, int]] = {50: {}, 100: {}}
     ot_points: int = 0
 
     food: Dict[str, int] = {"q1": 0, "q2": 0, "q3": 0, "q4": 0, "q5": 0, "q6": 0, "q7": 0, "total": 0}
@@ -40,9 +39,9 @@ class BaseCitizen(access_points.CitizenAPI):
     energy: classes.Energy = None
     details: classes.Details = None
     politics: classes.Politics = None
+    my_companies: classes.MyCompanies = None
     reporter: classes.Reporter = None
     stop_threads: Event = None
-    concurrency_available: Event = None
     telegram: classes.TelegramReporter = None
 
     r: Response = None
@@ -59,14 +58,11 @@ class BaseCitizen(access_points.CitizenAPI):
         self.my_companies = classes.MyCompanies(self)
         self.reporter = classes.Reporter(self)
         self.stop_threads = Event()
-        self.concurrency_available = Event()
-        self.concurrency_available.set()
         self.telegram = classes.TelegramReporter(stop_event=self.stop_threads)
 
         self.config.email = email
         self.config.password = password
-        self.inventory = {}
+        self._inventory = classes.Inventory()
-        self.inventory_status = dict(used=0, total=0)
         self.wheel_of_fortune = False
 
     def get_csrf_token(self):
@@ -241,33 +237,42 @@ class BaseCitizen(access_points.CitizenAPI):
 
     def update_inventory(self):
         """
-        Updates class properties and returns structured inventory.
+        Updates citizen inventory
-        Return structure: {status: {used: int, total: int}, items: {active/final/raw: {item_token:{quality: data}}}
-        If item kind is damageBoosters or aircraftDamageBoosters then kind is renamed to kind+quality and duration is
-        used as quality.
         """
         self._update_inventory_data(self._get_economy_inventory_items().json())
 
-    def get_inventory(self, force: bool = False):
+    @property
+    def inventory(self) -> classes.Inventory:
+        return self.get_inventory()
+
+    def get_inventory(self, force: bool = False) -> classes.Inventory:
         if utils.good_timedelta(self._last_inventory_update, timedelta(minutes=2)) < self.now or force:
             self.update_inventory()
-        return self.inventory
+        return self._inventory
 
     def _update_inventory_data(self, inv_data: Dict[str, Any]):
         if not isinstance(inv_data, dict):
             raise TypeError("Parameter `inv_data` must be dict not '{type(data)}'!")
 
+        def _expire_value_to_python(_expire_value: str) -> Dict[str, Union[int, datetime]]:
+            _data = re.search(
+                r'((?P<amount>\d+) item\(s\) )?[eE]xpires? on Day (?P<eday>\d,\d{3}), (?P<time>\d\d:\d\d)',
+                _expire_value).groupdict()
+            eday = utils.date_from_eday(int(_data['eday'].replace(',', '')))
+            dt = constants.erep_tz.localize(datetime.combine(eday, time(*[int(_) for _ in _data['time'].split(':')])))
+            return {'amount': _data.get('amount'), 'expiration': dt}
+
         status = inv_data.get("inventoryStatus", {})
         if status:
-            self.inventory_status.clear()
+            self._inventory.used = status.get("usedStorage")
-            self.inventory_status.update(used=status.get("usedStorage"), total=status.get("totalStorage"))
+            self._inventory.total = status.get("totalStorage")
         data = inv_data.get('inventoryItems', {})
         if not data:
             return
         self._last_inventory_update = self.now
         self.food.update({"q1": 0, "q2": 0, "q3": 0, "q4": 0, "q5": 0, "q6": 0, "q7": 0})
         self.eb_small = self.eb_double = self.eb_normal = 0
-        active_items: Dict[str, Dict[int, Dict[str, Union[str, int]]]] = {}
+        active_items: types.InvFinal = {}
         if data.get("activeEnhancements", {}).get("items", {}):
             for item_data in data.get("activeEnhancements", {}).get("items", {}).values():
                 if item_data.get('token'):
@@ -278,29 +283,35 @@ class BaseCitizen(access_points.CitizenAPI):
                     kind = constants.INDUSTRIES[constants.INDUSTRIES[kind]]
                 if kind not in active_items:
                     active_items[kind] = {}
-                icon = item_data['icon'] if item_data[
+                expiration_info = []
-                    'icon'] else "//www.erepublik.net/images/modules/manager/tab_storage.png"
+                if item_data.get('attributes').get('expirationInfo'):
-                item_data = dict(name=item_data.get("name"), time_left=item_data['active']['time_left'], icon=icon,
+                    expire_info = item_data.get('attributes').get('expirationInfo')
-                                 kind=kind,
+                    expiration_info = [_expire_value_to_python(v) for v in expire_info['value']]
-                                 quality=item_data.get("quality", 0))
+                if not item_data.get('icon') and item_data.get('isPackBooster'):
+                    item_data['icon'] = f"//www.erepublik.com/images/icons/boosters/52px/{item_data.get('type')}.png"
+                icon = item_data['icon'] if item_data['icon'] else "//www.erepublik.net/images/modules/manager/tab_storage.png"
+                inv_item: types.InvFinalItem = dict(
+                    name=item_data.get("name"), time_left=item_data['active']['time_left'], icon=icon,
+                    kind=kind, expiration=expiration_info, quality=item_data.get("quality", 0)
+                )
 
                 if item_data.get('isPackBooster'):
-                    active_items[kind].update({0: item_data})
+                    active_items[kind].update({0: inv_item})
                 else:
-                    active_items[kind].update({item_data.get("quality"): item_data})
+                    active_items[kind].update({inv_item.get("quality"): inv_item})
 
-        final_items: Dict[str, Dict[int, Dict[str, Union[str, int]]]] = {}
+        final_items: types.InvFinal = {}
+        boosters: types.InvBooster = {}
         if data.get("finalProducts", {}).get("items", {}):
             for item_data in data.get("finalProducts", {}).get("items", {}).values():
+                is_booster: bool = False
                 name = item_data['name']
 
                 if item_data.get('type'):
-                    if item_data.get('type') in ['damageBoosters', "aircraftDamageBoosters"]:
+                    #  in ['damageBoosters', "aircraftDamageBoosters", 'prestigePointsBoosters']
-                        kind = f"{item_data['type']}{item_data['quality']}"
+                    if item_data.get('isBooster'):
-                        if item_data['quality'] == 5:
+                        is_booster = True
-                            self.boosters[50].update({item_data['duration']: item_data['amount']})
+                        kind = item_data['type']
-                        elif item_data['quality'] == 10:
-                            self.boosters[100].update({item_data['duration']: item_data['amount']})
 
                         delta = item_data['duration']
                         if delta // 3600:
@@ -329,6 +340,9 @@ class BaseCitizen(access_points.CitizenAPI):
                             elif q == 15:
                                 self.eb_small += amount
                                 item_data.update(token='energy_bar')
+                            elif q == 16:
+                                self.eb_small += amount
+                                item_data.update(token='energy_bar')
                     kind = re.sub(r'_q\d\d*', "", item_data.get('token'))
 
                 if item_data.get('token', "") == "house_q100":
@@ -337,8 +351,14 @@ class BaseCitizen(access_points.CitizenAPI):
                 if constants.INDUSTRIES[kind]:
                     kind = constants.INDUSTRIES[constants.INDUSTRIES[kind]]
 
-                if kind not in final_items:
+                if is_booster:
-                    final_items[kind] = {}
+                    if kind not in boosters:
+                        boosters[kind] = {}
+                    if item_data.get('quality', 0) not in boosters[kind]:
+                        boosters[kind][item_data['quality']] = {}
+                else:
+                    if kind not in final_items:
+                        final_items[kind] = {}
 
                 if item_data['icon']:
                     icon = item_data['icon']
@@ -355,10 +375,23 @@ class BaseCitizen(access_points.CitizenAPI):
                         icon = "/images/modules/pvp/ghost_boosters/icon_booster_30_60.png"
                     else:
                         icon = "//www.erepublik.net/images/modules/manager/tab_storage.png"
-                _item_data = dict(kind=kind, quality=item_data.get('quality', 0), amount=item_data.get('amount', 0),
+
-                                  durability=item_data.get('duration', 0), icon=icon, name=name)
+                expiration_info = []
-                if item_data.get('type') in ('damageBoosters', "aircraftDamageBoosters"):
+                if item_data.get('attributes'):
-                    _item_data = {_item_data['durability']: _item_data}
+                    if item_data.get('attributes').get('expirationInfo'):
+                        expire_info = item_data.get('attributes').get('expirationInfo')
+                        expiration_info = [_expire_value_to_python(v) for v in expire_info['value']]
+                    elif item_data.get('attributes').get('expiration'):
+                        _exp = item_data.get('attributes').get('expiration')
+                        exp_dt = (utils.date_from_eday(int(_exp['value'].replace(',', ''))))
+                        expiration_info = [{'amount': item_data.get('amount'), 'expiration': exp_dt}]
+                _inv_item: Dict[int, types.InvFinalItem]
+                inv_item: types.InvFinalItem = dict(
+                    kind=kind, quality=item_data.get('quality', 0), icon=icon, expiration=expiration_info,
+                    amount=item_data.get('amount'), durability=item_data.get('duration', 0), name=name
+                )
+                if is_booster:
+                    _inv_item = {inv_item['durability']: inv_item}
                 else:
                     if item_data.get('type') == 'bomb':
                         firepower = 0
@@ -367,11 +400,14 @@ class BaseCitizen(access_points.CitizenAPI):
                         except AttributeError:
                             pass
                         finally:
-                            _item_data.update(fire_power=firepower)
+                            inv_item.update(fire_power=firepower)
-                    _item_data = {_item_data['quality']: _item_data}
+                    _inv_item = {inv_item['quality']: inv_item}
-                final_items[kind].update(_item_data)
+                if is_booster:
+                    boosters[kind][inv_item['quality']].update(_inv_item)
+                else:
+                    final_items[kind].update(_inv_item)
 
-        raw_materials: Dict[str, Dict[int, Dict[str, Union[str, int]]]] = {}
+        raw_materials: types.InvRaw = {}
         if data.get("rawMaterials", {}).get("items", {}):
             for item_data in data.get("rawMaterials", {}).get("items", {}).values():
                 if item_data['isPartial']:
@@ -401,8 +437,11 @@ class BaseCitizen(access_points.CitizenAPI):
                 offers[kind] = {}
 
             offers[kind].update(offer_data)
-        self.inventory.clear()
+        self._inventory.active = active_items
-        self.inventory.update(active=active_items, final=final_items, raw=raw_materials, offers=offers)
+        self._inventory.final = final_items
+        self._inventory.boosters = boosters
+        self._inventory.raw = raw_materials
+        self._inventory.offers = offers
         self.food["total"] = sum([self.food[q] * constants.FOOD_ENERGY[q] for q in constants.FOOD_ENERGY])
 
     def write_log(self, *args, **kwargs):
@@ -430,7 +469,7 @@ class BaseCitizen(access_points.CitizenAPI):
         self._req.debug = bool(debug)
 
     def to_json(self, indent: bool = False) -> str:
-        return utils.json.dumps(self, cls=classes.MyJSONEncoder, indent=4 if indent else None)
+        return utils.json.dumps(self, cls=classes.ErepublikJSONEncoder, indent=4 if indent else None, sort_keys=True)
 
     def get_countries_with_regions(self) -> Set[constants.Country]:
         r_json = self._post_main_travel_data().json()
@@ -444,13 +483,13 @@ class BaseCitizen(access_points.CitizenAPI):
         filename = f"{self.__class__.__name__}__dump.json"
         with open(filename, 'w') as f:
             utils.json.dump(dict(config=self.config, cookies=self._req.cookies.get_dict(),
-                                 user_agent=self._req.headers.get("User-Agent")), f, cls=classes.MyJSONEncoder)
+                                 user_agent=self._req.headers.get("User-Agent")), f, cls=classes.ErepublikJSONEncoder)
         self.write_log(f"Session saved to: '{filename}'")
 
     @classmethod
     def load_from_dump(cls, dump_name: str):
         with open(dump_name) as f:
-            data = utils.json.load(f)
+            data = utils.json.load(f, object_hook=utils.json_decode_object_hook)
         player = cls(data['config']['email'], "")
         player._req.cookies.update(data['cookies'])
         player._req.headers.update({"User-Agent": data['user_agent']})
@@ -470,7 +509,7 @@ class BaseCitizen(access_points.CitizenAPI):
             self.write_log(f"Resumed as: {self.name}")
             if re.search('<div id="accountSecurity" class="it-hurts-when-ip">', resp.text):
                 self.restricted_ip = True
-                self.report_error("eRepublik has blacklisted IP. Limited functionality!", True)
+                # self.report_error("eRepublik has blacklisted IP. Limited functionality!", True)
 
             self.logged_in = True
             self.get_csrf_token()
@@ -485,18 +524,29 @@ class BaseCitizen(access_points.CitizenAPI):
 
     @property
     def as_dict(self):
-        ret = self.__dict__.copy()
+        ret = super().as_dict
-        ret.pop('stop_threads', None)
+        ret.update(
-        ret.pop('_CitizenMilitary__last_war_update_data', None)
+            name=self.name, __str__=self.__str__(),
-        ret.update(_properties=dict(
+            ebs=dict(normal=self.eb_normal, double=self.eb_double, small=self.eb_small),
-            now=self.now, should_do_levelup=self.should_do_levelup, is_levelup_reachable=self.is_levelup_reachable,
+            promos=self.promos, inventory=self._inventory.as_dict, ot_points=self.ot_points, food=self.food,
-            max_time_till_full_ff=self.max_time_till_full_ff, is_levelup_close=self.is_levelup_close,
+            division=self.division, maveric=self.maverick, eday=self.eday, wheel_of_fortune=self.wheel_of_fortune,
-            time_till_full_ff=self.time_till_full_ff, time_till_week_change=self.time_till_week_change,
+            debug=self.debug,
-            next_wc_start=self.next_wc_start, next_reachable_energy=self.next_reachable_energy,
+            logged_in=self.logged_in, restricted_ip=self.restricted_ip, _properties=dict(
-            health_info=self.health_info))
+                now=self.now, should_do_levelup=self.should_do_levelup, is_levelup_reachable=self.is_levelup_reachable,
-
+                max_time_till_full_ff=self.max_time_till_full_ff, is_levelup_close=self.is_levelup_close,
+                time_till_full_ff=self.time_till_full_ff, time_till_week_change=self.time_till_week_change,
+                next_wc_start=self.next_wc_start, next_reachable_energy=self.next_reachable_energy,
+                health_info=self.health_info),
+            _last_full_update=self._last_full_update, _last_inventory_update=self._last_inventory_update,
+            config=self.config.as_dict, energy=self.energy.as_dict, details=self.details.as_dict,
+            politics=self.politics.as_dict, my_companies=self.my_companies.as_dict, reporter=self.reporter.as_dict,
+            telegram=self.telegram.as_dict, stop_threads=self.stop_threads.is_set(), response=self.r,
+        )
         return ret
 
+    def set_locks(self):
+        self.stop_threads.set()
+
     @property
     def health_info(self):
         ret = f"{self.energy.recovered}/{self.energy.limit} + {self.energy.recoverable}, " \
@@ -653,6 +703,10 @@ class BaseCitizen(access_points.CitizenAPI):
                 self.eb_double -= amount
             elif q == "12":
                 self.eb_small -= amount
+            elif q == "15":
+                self.eb_small -= amount
+            elif q == "16":
+                self.eb_small -= amount
         next_recovery = r_json.get("food_remaining_reset").split(":")
         self.energy.set_reference_time(
             utils.good_timedelta(self.now, timedelta(seconds=int(next_recovery[1]) * 60 + int(next_recovery[2])))
@@ -679,7 +733,7 @@ class BaseCitizen(access_points.CitizenAPI):
             self.get_csrf_token()
             if re.search('<div id="accountSecurity" class="it-hurts-when-ip">', self.r.text):
                 self.restricted_ip = True
-                self.report_error("eRepublik has blacklisted IP. Limited functionality!", True)
+                # self.report_error("eRepublik has blacklisted IP. Limited functionality!", True)
 
             self.logged_in = True
 
@@ -694,6 +748,9 @@ class BaseCitizen(access_points.CitizenAPI):
         if response.status_code >= 400:
             self.r = response
             if response.status_code >= 500:
+                if self.restricted_ip:
+                    self._req.cookies.clear()
+                    return True
                 self.write_log("eRepublik servers are having internal troubles. Sleeping for 5 minutes")
                 self.sleep(5 * 60)
             else:
@@ -725,7 +782,7 @@ class BaseCitizen(access_points.CitizenAPI):
         :param msg: Message about the action
         :param kwargs: Extra information regarding action
         """
-        kwargs = utils.json.loads(utils.json.dumps(kwargs or {}, cls=classes.MyJSONEncoder))
+        kwargs = utils.json.loads(utils.json.dumps(kwargs or {}, cls=classes.ErepublikJSONEncoder))
         action = action[:32]
         self.write_log(msg)
         if self.reporter.allowed:
@@ -936,7 +993,6 @@ class CitizenCompanies(BaseCitizen):
     def work_as_manager_in_holding(self, holding: classes.Holding) -> Optional[Dict[str, Any]]:
         return self._work_as_manager(holding)
 
-    @utils.wait_for_lock
     def _work_as_manager(self, wam_holding: classes.Holding) -> Optional[Dict[str, Any]]:
         if self.restricted_ip:
             return None
@@ -946,13 +1002,13 @@ class CitizenCompanies(BaseCitizen):
         raw_factories = wam_holding.get_wam_companies(raw_factory=True)
         fin_factories = wam_holding.get_wam_companies(raw_factory=False)
 
-        free_inventory = self.inventory_status["total"] - self.inventory_status["used"]
+        free_inventory = self.inventory.total - self.inventory.used
         wam_list = raw_factories + fin_factories
         wam_list = wam_list[:self.energy.food_fights]
 
         if int(free_inventory * 0.75) < self.my_companies.get_needed_inventory_usage(wam_list):
             self.update_inventory()
-            free_inventory = self.inventory_status["total"] - self.inventory_status["used"]
+            free_inventory = self.inventory.total - self.inventory.used
 
         while wam_list and free_inventory < self.my_companies.get_needed_inventory_usage(wam_list):
             wam_list.pop(-1)
@@ -1006,7 +1062,7 @@ class CitizenCompanies(BaseCitizen):
 
 
 class CitizenEconomy(CitizenTravel):
-    def update_money(self, page: int = 0, currency: int = 62) -> Dict[str, Any]:
+    def update_money(self, page: int = 0, currency: int = 62):
         """
         Gets monetary market offers to get exact amount of CC and Gold available
         """
@@ -1016,12 +1072,11 @@ class CitizenEconomy(CitizenTravel):
         resp_data = resp.json()
         self.details.cc = float(resp_data.get("ecash").get("value"))
         self.details.gold = float(resp_data.get("gold").get("value"))
-        return resp_data
 
     def check_house_durability(self) -> Dict[int, datetime]:
         ret = {}
-        inv = self.get_inventory()
+        inv = self.inventory
-        for house_quality, active_house in inv['active'].get('House', {}).items():
+        for house_quality, active_house in inv.active.get('House', {}).items():
             till = utils.good_timedelta(self.now, timedelta(seconds=active_house['time_left']))
             ret.update({house_quality: till})
         return ret
@@ -1029,8 +1084,8 @@ class CitizenEconomy(CitizenTravel):
     def buy_and_activate_house(self, q: int) -> Optional[Dict[int, datetime]]:
         original_region = self.details.current_country, self.details.current_region
         ok_to_activate = False
-        inv = self.get_inventory()
+        inv = self.inventory
-        if not inv['final'].get('House', {}).get(q, {}):
+        if not inv.final.get('House', {}).get(q, {}):
             countries = [self.details.citizenship, ]
             if self.details.current_country != self.details.citizenship:
                 countries.append(self.details.current_country)
@@ -1038,7 +1093,7 @@ class CitizenEconomy(CitizenTravel):
             local_cheapest = sorted(offers, key=lambda o: o.price)[0]
 
             global_cheapest = self.get_market_offers("House", q)[f"q{q}"]
-            if global_cheapest.price + 200 < local_cheapest.price:
+            if global_cheapest.price + 2000 < local_cheapest.price:
                 if global_cheapest.price + 2000 < self.details.cc:
                     if self.travel_to_country(global_cheapest.country):
                         buy = self.buy_market_offer(global_cheapest, 1)
@@ -1084,7 +1139,7 @@ class CitizenEconomy(CitizenTravel):
         r: Dict[str, Any] = self._post_economy_activate_house(quality).json()
         self._update_inventory_data(r)
         if r.get("status") and not r.get("error"):
-            house: Dict[str, Union[int, str]] = self.get_inventory()['active']['House'][quality]
+            house = self.inventory.active.get('House', {}).get(quality)
             time_left = timedelta(seconds=house["time_left"])
             active_until = utils.good_timedelta(self.now, time_left)
             self._report_action(
@@ -1164,12 +1219,13 @@ class CitizenEconomy(CitizenTravel):
             self.write_log(f"Trying to sell unsupported industry {industry}")
 
         _inv_qlt = quality if industry in [1, 2, 3, 4, 23] else 0
-        _kind = 'final' if industry in [1, 2, 4, 23] else 'raw'
+        final_kind = industry in [1, 2, 4, 23]
-        inventory = self.get_inventory()
+        items = (self.inventory.final if final_kind else self.inventory.raw).get(constants.INDUSTRIES[industry],
-        items = inventory[_kind].get(constants.INDUSTRIES[industry], {_inv_qlt: {'amount': 0}})
+                                                                                 {_inv_qlt: {'amount': 0}})
         if items[_inv_qlt]['amount'] < amount:
-            inventory = self.get_inventory(True)
+            self.update_inventory()
-            items = inventory[_kind].get(constants.INDUSTRIES[industry], {_inv_qlt: {'amount': 0}})
+            items = (self.inventory.final if final_kind else self.inventory.raw).get(constants.INDUSTRIES[industry],
+                                                                                     {_inv_qlt: {'amount': 0}})
             if items[_inv_qlt]['amount'] < amount:
                 self._report_action("ECONOMY_SELL_PRODUCTS", "Unable to sell! Not enough items in storage!",
                                     kwargs=dict(inventory=items[_inv_qlt], amount=amount))
@@ -1199,7 +1255,6 @@ class CitizenEconomy(CitizenTravel):
             self._report_action("BOUGHT_PRODUCTS", json_ret.get('message'), kwargs=json_ret)
         return json_ret
 
-    @utils.wait_for_lock
     def buy_market_offer(self, offer: OfferItem, amount: int = None) -> Optional[Dict[str, Any]]:
         if amount is None or amount > offer.amount:
             amount = offer.amount
@@ -1326,7 +1381,7 @@ class CitizenEconomy(CitizenTravel):
         self.update_money()
         cur = "g" if currency == 62 else "cc"
         if success:
-            self._report_action("DONATE_MONEY", f"Successfully donated {amount}{cur} to citizen with id {citizen_id}!")
+            self.report_money_donation(citizen_id, amount, currency == 1)
         else:
             self._report_action("DONATE_MONEY", f"Unable to donate {amount}{cur}!")
         return success
@@ -1410,6 +1465,16 @@ class CitizenEconomy(CitizenTravel):
                                                    f" treasury", kwargs=r.json())
             return False
 
+    def report_money_donation(self, citizen_id: int, amount: float, is_currency: bool = True):
+        self.reporter.report_money_donation(citizen_id, amount, is_currency)
+        if self.config.telegram:
+            self.telegram.report_money_donation(citizen_id, amount, is_currency)
+
+    def report_item_donation(self, citizen_id: int, amount: float, quality: int, industry: str):
+        self.reporter.report_item_donation(citizen_id, amount, quality, industry)
+        if self.config.telegram:
+            self.telegram.report_item_donation(citizen_id, amount, f"{industry} q{quality}")
+
 
 class CitizenLeaderBoard(BaseCitizen):
     def get_aircraft_damage_rankings(self, country: int, weeks: int = 0, mu: int = 0) -> Dict[str, any]:
@@ -1490,11 +1555,15 @@ class CitizenMedia(BaseCitizen):
 
 class CitizenMilitary(CitizenTravel):
     all_battles: Dict[int, classes.Battle] = None
-    countries: Dict[int, Dict[str, Union[str, List[int]]]] = None
     __last_war_update_data = None
 
     active_fs: bool = False
-    boosters: Dict[int, Dict[int, int]] = {100: {}, 50: {}}
+
+    @property
+    def as_dict(self):
+        d = super().as_dict
+        d.update(active_fs=self.active_fs, all_battles=self.all_battles)
+        return d
 
     def update_war_info(self):
         if self.__last_war_update_data and self.__last_war_update_data.get('last_updated',
@@ -1505,17 +1574,6 @@ class CitizenMilitary(CitizenTravel):
         if r_json.get("countries"):
             if self.all_battles is None:
                 self.all_battles = {}
-            if self.countries is None:
-                self.countries = {}
-            countries = {}
-            for c_id, c_data in r_json.get("countries").items():
-                if int(c_id) not in countries:
-                    countries.update({
-                        int(c_id): {"name": c_data.get("name"), "allies": c_data.get("allies")}
-                    })
-                else:
-                    countries[int(c_id)].update(allies=c_data.get("allies"))
-            self.countries = countries
             self.__last_war_update_data = r_json
             if r_json.get("battles"):
                 all_battles = {}
@@ -1735,7 +1793,8 @@ class CitizenMilitary(CitizenTravel):
             yield battle, battle_zone, side
 
     def find_battle_and_fight(self):
-        if self.should_fight()[0]:
+        count = self.should_fight()[0]
+        if count:
             self.write_log("Checking for battles to fight in...")
             for battle, division, side in self.find_battle_to_fight():
 
@@ -1762,25 +1821,26 @@ class CitizenMilitary(CitizenTravel):
 
                 if self.change_division(battle, division):
                     self.set_default_weapon(battle, division)
-                    self.fight(battle, division, side)
+                    self.fight(battle, division, side, count)
                     self.travel_to_residence()
                     break
 
-    @utils.wait_for_lock
     def fight(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide = None,
-              count: int = None) -> Optional[int]:
+              count: int = None, use_ebs: bool = False) -> Optional[int]:
         """Fight in a battle.
 
         Will auto activate booster and travel if allowed to do it.
         :param battle: Battle battle to fight in
         :type battle: Battle
+        :param division: Division number to fight in available choices
+        :type division: BattleDivision
         :param side: BattleSide or None. Battle side to fight in, If side not == invader id or not in invader deployed
         allies list, then defender's side is chosen
         :type side: BattleSide
         :param count: How many hits to do, if not specified self.should_fight() is called.
         :type count: int
-        :param division: Division number to fight in available choices
+        :param use_ebs: Should use energy bars if count > 0 and not enough food_fights
-        :type division: BattleDivision
+        :type use_ebs: bool
         :return: None if no errors while fighting, otherwise error count.
         :rtype: int
         """
@@ -1788,7 +1848,7 @@ class CitizenMilitary(CitizenTravel):
             self._report_action("IP_BLACKLISTED", "Fighting is not allowed from restricted IP!")
             return 1
         if not division.is_air and self.config.boosters:
-            self.activate_dmg_booster()
+            self.activate_damage_booster(not division.is_air)
         if side is None:
             side = battle.defender if self.details.citizenship in battle.defender.allies + [
                 battle.defender.country] else battle.invader
@@ -1810,15 +1870,13 @@ class CitizenMilitary(CitizenTravel):
                 error_count += error
             else:
                 self._eat('blue')
+                if count > 0 and self.energy.recovered < 50 and use_ebs:
+                    self._eat('orange')
                 if self.energy.recovered < 50 or error_count >= 10 or count <= 0:
                     self.write_log(f"Hits: {total_hits:>4} | Damage: {total_damage}")
                     ok_to_fight = False
                     if total_damage:
-                        self.reporter.report_fighting(battle, not side.is_defender, division, total_damage, total_hits)
+                        self.report_fighting(battle, not side.is_defender, division, total_damage, total_hits)
-                        # self.reporter.report_action('FIGHT', dict(battle_id=battle.id, side=side, dmg=total_damage,
-                        #                                           air=battle.has_air, hits=total_hits,
-                        #                                           round=battle.zone_id,
-                        #                                           extra=dict(battle=battle, side=side)))
         return error_count
 
     def _shoot(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide):
@@ -1873,7 +1931,7 @@ class CitizenMilitary(CitizenTravel):
             else:
                 hits = r_json['hits']
                 if r_json['user']['epicBattle']:
-                    hits /= 1+r_json['user']['epicBattle']
+                    hits /= 1 + r_json['user']['epicBattle']
 
             self.energy.recovered = r_json["details"]["wellness"]
             self.details.xp = int(r_json["details"]["points"])
@@ -1883,8 +1941,8 @@ class CitizenMilitary(CitizenTravel):
 
         return hits, err, damage
 
-    @utils.wait_for_lock
+    def deploy_bomb(self, battle: classes.Battle, division: classes.BattleDivision, bomb_id: int, inv_side: bool,
-    def deploy_bomb(self, battle: classes.Battle, division: classes.BattleDivision, bomb_id: int, inv_side: bool, count: int = 1) -> Optional[int]:
+                    count: int = 1) -> Optional[int]:
         """Deploy bombs in a battle for given side.
 
         :param battle: Battle
@@ -1979,34 +2037,49 @@ class CitizenMilitary(CitizenTravel):
 
         return utils.calculate_hit(0, rang, True, elite, ne, 0, 20 if weapon else 0)
 
-    def activate_dmg_booster(self):
+    def activate_damage_booster(self, ground: bool = True) -> int:
-        if self.config.boosters:
+        kind = 'damage' if ground else 'aircraftDamage'
-            if not self.get_active_ground_damage_booster():
+        if self.config.boosters and not self.get_active_damage_booster(ground):
-                duration = 0
+            booster: Optional[types.InvFinalItem] = None
-                for length, amount in self.boosters[50].items():
+            for quality, data in sorted(self.inventory.boosters.get(kind, {}).items(), key=lambda x: x[0]):
-                    if amount > 2:
+                for _duration, _booster in sorted(data.items(), key=lambda y: y[0]):
-                        duration = length
+                    critical_amount = 2 if quality < 10 and ground else 10
+                    if _booster.get('amount') > critical_amount:
+                        booster = _booster
                         break
-                if duration:
+                break
-                    self._report_action("MILITARY_BOOSTER", f"Activated 50% {duration / 60}h damage booster")
+            if booster:
-                    self._post_economy_activate_booster(5, duration, "damage")
+                kind = 'damage' if ground else 'air_damage'
+                self._report_action("MILITARY_BOOSTER", f"Activated {booster['name']}")
+                resp = self._post_economy_activate_booster(booster['quality'], booster['durability'], kind).json()
+                self._update_inventory_data(resp)
+        return self.get_active_damage_booster(ground)
 
-    def get_active_ground_damage_booster(self) -> int:
+    def get_active_damage_booster(self, ground: bool = True) -> int:
-        inventory = self.get_inventory()
+        kind = 'damage' if ground else 'aircraftDamage'
+        boosters = self.inventory.active.get(kind, {})
         quality = 0
-        if inventory['active'].get('damageBoosters', {}).get(10):
+        for q, boost in boosters.items():
-            quality = 100
+            if boost['quality'] * 10 > quality:
-        elif inventory['active'].get('damageBoosters', {}).get(5):
+                quality = boost['quality'] * 10
-            quality = 50
         return quality
 
-    def activate_battle_effect(self, battle_id: int, kind: str) -> Response:
+    def get_active_ground_damage_booster(self) -> int:
-        self._report_action('MILITARY_BOOSTER', f'Activated {kind} booster')
+        return self.get_active_damage_booster(True)
-        return self._post_main_activate_battle_effect(battle_id, kind, self.details.citizen_id)
 
-    def activate_pp_booster(self, battle_id: int) -> Response:
+    def get_active_air_damage_booster(self) -> int:
-        self._report_action('MILITARY_BOOSTER', 'Activated PrestigePoint booster')
+        return self.get_active_damage_booster(False)
-        return self._post_military_fight_activate_booster(battle_id, 1, 180, "prestige_points")
+
+    def activate_battle_effect(self, battle_id: int, kind: str) -> bool:
+        self._report_action('MILITARY_BOOSTER', f'Activated {kind} booster')
+        resp = self._post_main_activate_battle_effect(battle_id, kind, self.details.citizen_id).json()
+        return not resp.get('error')
+
+    def activate_pp_booster(self, pp_item: types.InvFinalItem) -> bool:
+        self._report_action('MILITARY_BOOSTER', f'Activated {pp_item["name"]}')
+        resp = self._post_economy_activate_booster(pp_item['quality'], pp_item['durability'], 'prestige_points').json()
+        self._update_inventory_data(resp)
+        return pp_item.get('kind') in self.inventory.active
 
     def _rw_choose_side(self, battle: classes.Battle, side: classes.BattleSide) -> Response:
         return self._post_main_battlefield_travel(side.id, battle.id)
@@ -2167,6 +2240,11 @@ class CitizenMilitary(CitizenTravel):
                 if division.wall['dom'] == 50 or division.wall['dom'] > 98:
                     yield division, division.wall['for'] == battle.invader.country.id
 
+    def report_fighting(self, battle: classes.Battle, invader: bool, division: classes.BattleDivision, damage: float, hits: int):
+        self.reporter.report_fighting(battle, invader, division, damage, hits)
+        if self.config.telegram:
+            self.telegram.report_fight(battle, invader, division, damage, hits)
+
 
 class CitizenPolitics(BaseCitizen):
     def get_country_parties(self, country: constants.Country = None) -> dict:
@@ -2181,7 +2259,8 @@ class CitizenPolitics(BaseCitizen):
             self._report_action('POLITIC_PARTY_PRESIDENT', 'Applied for party president elections')
             return self._get_candidate_party(self.politics.party_slug)
         else:
-            self._report_action('POLITIC_CONGRESS', 'Unable to apply for party president elections - not a party member')
+            self._report_action('POLITIC_CONGRESS',
+                                'Unable to apply for party president elections - not a party member')
             return None
 
     def candidate_for_congress(self, presentation: str = "") -> Optional[Response]:
@@ -2319,6 +2398,12 @@ class CitizenTasks(CitizenEconomy):
     ot_points: int = 0
     next_ot_time: datetime = None
 
+    @property
+    def as_dict(self):
+        d = super().as_dict
+        d.update(tg_contract=self.tg_contract, ot_points=self.ot_points, next_ot_time=self.next_ot_time)
+        return d
+
     def eat(self):
         """ Eat food """
         self._eat("blue")
@@ -2446,8 +2531,8 @@ class CitizenTasks(CitizenEconomy):
             self.ot_points = ot.get("points", 0)
 
 
-class Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
+class _Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
-              CitizenMedia, CitizenPolitics, CitizenSocial, CitizenMilitary, CitizenTasks):
+               CitizenMedia, CitizenPolitics, CitizenSocial, CitizenMilitary, CitizenTasks):
     def __init__(self, email: str = "", password: str = "", auto_login: bool = False):
         super().__init__(email, password)
         self._last_full_update = constants.min_datetime
@@ -2458,10 +2543,18 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
     @classmethod
     def load_from_dump(cls, dump_name: str = ""):
         filename = dump_name if dump_name else f"{cls.__name__}__dump.json"
-        player: Citizen = super().load_from_dump(filename)  # noqa
+        player: _Citizen = super().load_from_dump(filename)  # noqa
         player.login()
         return player
 
+    def _eat(self, colour: str = "blue") -> Response:
+        resp = super()._eat(colour)
+        if not any([resp.json().get("units_consumed").values()]):
+            if colour == 'orange' and resp.json().get('food_remaining'):
+                self.eat()
+            return self._eat(colour)
+        return resp
+
     def config_setup(self, **kwargs):
         self.config.reset()
         for key, value in kwargs.items():
@@ -2565,17 +2658,21 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
         data = self._get_main_weekly_challenge_data().json()
         self.details.pp = data.get("player", {}).get("prestigePoints", 0)
         self.details.next_pp.clear()
+        max_collectable_id = data.get('maxRewardId')
+        should_collect = False
         for reward in data.get("rewards", {}).get("normal", {}):
             status = reward.get("status", "")
             if status == "rewarded":
                 continue
             elif status == "completed":
-                self._post_main_weekly_challenge_reward(reward.get("id", 0))
+                should_collect = True
             elif reward.get("icon", "") == "energy_booster":
                 pps = re.search(r"Reach (\d+) Prestige Points to unlock the following reward: \+1 Energy",
                                 reward.get("tooltip", ""))
                 if pps:
                     self.details.next_pp.append(int(pps.group(1)))
+        if should_collect:
+            self._post_main_weekly_challenge_collect_all(max_collectable_id)
 
     def should_fight(self, silent: bool = True) -> Tuple[int, str, bool]:
         count, log_msg, force_fight = super().should_fight()
@@ -2612,16 +2709,19 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
 
     def state_update_repeater(self):
         try:
-            start_time = self.now.replace(second=0, microsecond=0)
+            start_time = self.now.replace(minute=(self.now.minute // 10) * 10, second=0, microsecond=0)
-            if start_time.minute <= 30:
+            if not self.restricted_ip:
-                start_time = start_time.replace(minute=30)
+                if start_time.minute <= 30:
-            else:
+                    start_time = start_time.replace(minute=30)
-                start_time = utils.good_timedelta(start_time.replace(minute=0), timedelta(hours=1))
+                else:
+                    start_time = utils.good_timedelta(start_time.replace(minute=0), timedelta(hours=1))
             while not self.stop_threads.is_set():
+                start_time = utils.good_timedelta(start_time, timedelta(minutes=10 if self.restricted_ip else 30))
                 self.update_citizen_info()
-                start_time = utils.good_timedelta(start_time, timedelta(minutes=30))
+                self.update_weekly_challenge()
                 self.send_state_update()
                 self.send_inventory_update()
+                self.update_companies()
                 self.send_my_companies_update()
                 sleep_seconds = (start_time - self.now).total_seconds()
                 self.stop_threads.wait(sleep_seconds if sleep_seconds > 0 else 0)
@@ -2630,13 +2730,13 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
 
     def send_state_update(self):
         data = dict(xp=self.details.xp, cc=self.details.cc, gold=self.details.gold, pp=self.details.pp,
-                    inv_total=self.inventory_status['total'], inv=self.inventory_status['used'],
+                    inv_total=self.inventory.total, inv=self.inventory.used,
                     hp_limit=self.energy.limit,
                     hp_interval=self.energy.interval, hp_available=self.energy.available, food=self.food['total'], )
         self.reporter.send_state_update(**data)
 
     def send_inventory_update(self):
-        self.reporter.report_action("INVENTORY", json_val=self.get_inventory(True))
+        self.reporter.report_action("INVENTORY", json_val=self.inventory.as_dict)
 
     def send_my_companies_update(self):
         self.reporter.report_action('COMPANIES', json_val=self.my_companies.as_dict)
@@ -2774,7 +2874,7 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
 
             for holding in regions.values():
                 raw_usage = holding.get_wam_raw_usage()
-                free_storage = self.inventory_status['total'] - self.inventory_status['used']
+                free_storage = self.inventory.total - self.inventory.used
                 if (raw_usage['frm'] + raw_usage['wrm']) * 100 > free_storage:
                     self._report_action('WAM_UNAVAILABLE', 'Not enough storage!')
                     continue
@@ -2813,3 +2913,161 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
                 self.stop_threads.wait(90)
             except:  # noqa
                 self.report_error('Command central is broken')
+
+
+class Citizen(_Citizen):
+    _concurrency_lock: Event
+    _update_lock: Event
+    _update_timeout: int = 10
+    _concurrency_timeout: int = 600
+
+    def __init__(self, *args, **kwargs):
+        self._concurrency_lock = Event()
+        self._concurrency_lock.set()
+        self._update_lock = Event()
+        self._update_lock.set()
+        super().__init__(*args, **kwargs)
+
+    def update_weekly_challenge(self):
+        if not self._update_lock.wait(self._update_timeout):
+            e = f'Update concurrency not freed in {self._update_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._update_lock.clear()
+            super().update_weekly_challenge()
+        finally:
+            self._update_lock.set()
+
+    def update_companies(self):
+        if not self._update_lock.wait(self._update_timeout):
+            e = f'Update concurrency not freed in {self._update_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._update_lock.clear()
+            super().update_companies()
+        finally:
+            self._update_lock.set()
+
+    def update_war_info(self):
+        if not self._update_lock.wait(self._update_timeout):
+            e = f'Update concurrency not freed in {self._update_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._update_lock.clear()
+            super().update_war_info()
+        finally:
+            self._update_lock.set()
+
+    def update_job_info(self):
+        if not self._update_lock.wait(self._update_timeout):
+            e = f'Update concurrency not freed in {self._update_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._update_lock.clear()
+            super().update_job_info()
+        finally:
+            self._update_lock.set()
+
+    def update_money(self, page: int = 0, currency: int = 62):
+        if not self._update_lock.wait(self._update_timeout):
+            e = f'Update concurrency not freed in {self._update_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._update_lock.clear()
+            super().update_money(page, currency)
+        finally:
+            self._update_lock.set()
+
+    def update_inventory(self):
+        if not self._update_lock.wait(self._update_timeout):
+            e = f'Update concurrency not freed in {self._update_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._update_lock.clear()
+            super().update_inventory()
+        finally:
+            self._update_lock.set()
+
+    def _work_as_manager(self, wam_holding: classes.Holding) -> Optional[Dict[str, Any]]:
+        if not self._concurrency_lock.wait(self._concurrency_timeout):
+            e = f'Concurrency not freed in {self._concurrency_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._concurrency_lock.clear()
+            return super()._work_as_manager(wam_holding)
+        finally:
+            self._concurrency_lock.set()
+
+    def fight(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide = None,
+              count: int = None, use_ebs: bool = False) -> Optional[int]:
+        if not self._concurrency_lock.wait(self._concurrency_timeout):
+            e = f'Concurrency not freed in {self._concurrency_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._concurrency_lock.clear()
+            return super().fight(battle, division, side, count, use_ebs)
+        finally:
+            self._concurrency_lock.set()
+
+    def deploy_bomb(self, battle: classes.Battle, division: classes.BattleDivision, bomb_id: int, inv_side: bool,
+                    count: int = 1) -> Optional[int]:
+        if not self._concurrency_lock.wait(self._concurrency_timeout):
+            e = f'Concurrency not freed in {self._concurrency_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._concurrency_lock.clear()
+            return super().deploy_bomb(battle, division, bomb_id, inv_side, count)
+        finally:
+            self._concurrency_lock.set()
+
+    def buy_market_offer(self, offer: OfferItem, amount: int = None) -> Optional[Dict[str, Any]]:
+        if not self._concurrency_lock.wait(self._concurrency_timeout):
+            e = f'Concurrency not freed in {self._concurrency_timeout}sec!'
+            self.write_log(e)
+            if self.debug:
+                self.report_error(e)
+            return None
+        try:
+            self._concurrency_lock.clear()
+            return super().buy_market_offer(offer, amount)
+        finally:
+            self._concurrency_lock.set()
+
+    @property
+    def as_dict(self):
+        d = super().as_dict
+        d.update(locks=dict(concurrency_lock=self._concurrency_lock.is_set(), update_lock=self._update_lock.is_set(),
+                            concurrency_timeout=self._concurrency_timeout, update_timeout=self._update_timeout))
+        return d
+
+    def set_locks(self):
+        super().set_locks()
+        self._concurrency_lock.set()
+        self._update_lock.set()

erepublik/classes.py

@@ -3,15 +3,15 @@ import hashlib
 import threading
 import weakref
 from decimal import Decimal
-from typing import Any, Dict, Generator, Iterable, List, NamedTuple, NoReturn, Tuple, Union
+from typing import Any, Dict, Generator, Iterable, List, NamedTuple, NoReturn, Union
 
 from requests import Response, Session, post
 
-from . import constants, utils
+from . import constants, types, utils
 
 __all__ = ['Battle', 'BattleDivision', 'BattleSide', 'Company', 'Config', 'Details', 'Energy', 'ErepublikException',
-           'ErepublikNetworkException', 'EnergyToFight',
+           'ErepublikJSONEncoder', 'ErepublikNetworkException', 'EnergyToFight', 'Holding', 'Inventory', 'MyCompanies',
-           'Holding', 'MyCompanies', 'MyJSONEncoder', 'OfferItem', 'Politics', 'Reporter', 'TelegramReporter']
+           'OfferItem', 'Politics', 'Reporter', 'TelegramReporter', ]
 
 
 class ErepublikException(Exception):
@@ -396,11 +396,11 @@ class Config:
         self.spin_wheel_of_fortune = False
 
     @property
-    def as_dict(self):
+    def as_dict(self) -> Dict[str, Union[bool, int, str, List[str]]]:
         return dict(email=self.email, work=self.work, train=self.train, wam=self.wam, ot=self.ot,
                     auto_sell=self.auto_sell, auto_sell_all=self.auto_sell_all, employees=self.employees,
                     fight=self.fight, air=self.air, ground=self.ground, all_in=self.all_in,
-                    next_energy=self.next_energy, boosters=self.boosters, travel_to_fight=self.travel_to_fight,
+                    next_energy=self.next_energy, 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, maverick=self.maverick,
                     continuous_fighting=self.continuous_fighting, auto_buy_raw=self.auto_buy_raw,
@@ -454,7 +454,7 @@ class Energy:
         return self.recovered + self.recoverable
 
     @property
-    def as_dict(self):
+    def as_dict(self) -> Dict[str, Union[int, datetime.datetime, bool]]:
         return dict(limit=self.limit, interval=self.interval, recoverable=self.recoverable, recovered=self.recovered,
                     reference_time=self.reference_time, food_fights=self.food_fights,
                     is_recoverable_full=self.is_recoverable_full, is_recovered_full=self.is_recovered_full,
@@ -509,7 +509,7 @@ class Details:
         return next_level_up - self.xp
 
     @property
-    def as_dict(self):
+    def as_dict(self) -> Dict[str, Union[int, float, str, constants.Country, bool]]:
         return dict(xp=self.xp, cc=self.cc, pp=self.pp, pin=self.pin, gold=self.gold, next_pp=self.next_pp,
                     citizen_id=self.citizen_id, citizenship=self.citizenship, current_region=self.current_region,
                     current_country=self.current_country, residence_region=self.residence_region,
@@ -528,7 +528,7 @@ class Politics:
     is_country_president: bool = False
 
     @property
-    def as_dict(self):
+    def as_dict(self) -> Dict[str, Union[bool, int, str]]:
         return dict(is_party_member=self.is_party_member, party_id=self.party_id, party_slug=self.party_slug,
                     is_party_president=self.is_party_president, is_congressman=self.is_congressman,
                     is_country_president=self.is_country_president)
@@ -566,7 +566,7 @@ class Reporter:
         return self.citizen.details.citizen_id
 
     @property
-    def as_dict(self):
+    def as_dict(self) -> Dict[str, Union[bool, int, str, List[Dict[Any, Any]]]]:
         return dict(name=self.name, email=self.email, citizen_id=self.citizen_id, key=self.key, allowed=self.allowed,
                     queue=self.__to_update)
 
@@ -598,10 +598,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.loads(utils.json.dumps(unreported_data, cls=MyJSONEncoder))
+                unreported_data = utils.json.loads(utils.json.dumps(unreported_data, cls=ErepublikJSONEncoder))
                 self._req.post(f"{self.url}/bot/update", json=unreported_data)
             self.__to_update.clear()
-        data = utils.json.loads(utils.json.dumps(data, cls=MyJSONEncoder))
+        data = utils.json.loads(utils.json.dumps(data, cls=ErepublikJSONEncoder))
         r = self._req.post(f"{self.url}/bot/update", json=data)
         return r
 
@@ -649,6 +649,16 @@ class Reporter:
                                          air=battle.has_air, hits=hits,
                                          round=battle.zone_id, extra=dict(battle=battle, side=side, division=division)))
 
+    def report_money_donation(self, citizen_id: int, amount: float, is_currency: bool = True):
+        cur = 'cc' if is_currency else 'gold'
+        self.report_action('DONATE_MONEY', dict(citizen_id=citizen_id, amount=amount, currency=cur),
+                           f"Successfully donated {amount}{cur} to citizen with id {citizen_id}!")
+
+    def report_item_donation(self, citizen_id: int, amount: float, quality: int, industry: str):
+        self.report_action('DONATE_ITEMS',
+                           dict(citizen_id=citizen_id, amount=amount, quality=quality, industry=industry),
+                           f"Successfully donated {amount} x {industry} q{quality} to citizen with id {citizen_id}!")
+
     def report_promo(self, kind: str, time_until: datetime.datetime):
         self._req.post(f"{self.url}/promos/add/", data=dict(kind=kind, time_untill=time_until))
 
@@ -660,16 +670,19 @@ class Reporter:
         except:  # noqa
             return []
 
-    def fetch_tasks(self) -> List[Union[str, Tuple[Any]]]:
+    def fetch_tasks(self) -> List[Dict[str, Any]]:
         try:
-            task_response = self._req.get(f'{self.url}/api/v1/command',
+            task_response = self._req.post(
-                                          params=dict(citizen=self.citizen_id, key=self.key))
+                f'{self.url}/api/v1/command', data=dict(citizen=self.citizen_id, key=self.key)).json()
-            return task_response.json().get('task_collection')
+            if task_response.get('status'):
+                return task_response.get('data')
+            else:
+                return []
         except:  # noqa
             return []
 
 
-class MyJSONEncoder(utils.json.JSONEncoder):
+class ErepublikJSONEncoder(utils.json.JSONEncoder):
     def default(self, o):
         from erepublik.citizen import Citizen
         if isinstance(o, Decimal):
@@ -683,7 +696,7 @@ class MyJSONEncoder(utils.json.JSONEncoder):
             return dict(__type__='timedelta', days=o.days, seconds=o.seconds,
                         microseconds=o.microseconds, total_seconds=o.total_seconds())
         elif isinstance(o, Response):
-            return dict(headers=o.headers.__dict__, url=o.url, text=o.text)
+            return dict(headers=dict(o.__dict__['headers']), url=o.url, text=o.text, status_code=o.status_code)
         elif hasattr(o, 'as_dict'):
             return o.as_dict
         elif isinstance(o, set):
@@ -730,7 +743,7 @@ class BattleSide:
         return self.country.iso
 
     @property
-    def as_dict(self):
+    def as_dict(self) -> Dict[str, Union[int, constants.Country, bool, List[constants.Country]]]:
         return dict(points=self.points, country=self.country, is_defender=self.is_defender, allies=self.allies,
                     deployed=self.deployed)
 
@@ -973,7 +986,7 @@ class TelegramReporter:
         self._last_time = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-5))
         self._last_full_energy_report = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-30))
         if self.__queue:
-            self.send_message("\n\n––––––––––––––––––––––\n\n".join(self.__queue))
+            self.send_message("Telegram initialized")
 
     def send_message(self, message: str) -> bool:
         self.__queue.append(message)
@@ -1001,15 +1014,29 @@ class TelegramReporter:
         new_line = '\n' if multiple else ''
         self.send_message(f"New award: {new_line}*{msg}*")
 
+    def report_fight(self, battle: "Battle", invader: bool, division: "BattleDivision", damage: float, hits: int):
+        side_txt = (battle.invader if invader else battle.defender).country.iso
+        self.send_message(f"*Fight report*:\n{int(damage):,d} dmg ({hits} hits) in"
+                          f" [battle {battle.id} for {battle.region_name[:16]}]({battle.link}) in d{division.div} on "
+                          f"{side_txt} side")
+
+    def report_item_donation(self, citizen_id: int, amount: float, product: str):
+        self.send_message(f"*Donation*: {amount} x {product} to citizen "
+                          f"[{citizen_id}](https://www.erepublik.com/en/citizen/profile/{citizen_id})")
+
+    def report_money_donation(self, citizen_id: int, amount: float, is_currency: bool = True):
+        self.send_message(f"*Donation*: {amount}{'cc' if is_currency else 'gold'} to citizen "
+                          f"[{citizen_id}](https://www.erepublik.com/en/citizen/profile/{citizen_id})")
+
     def __send_messages(self):
         while self._next_time > utils.now():
             if self.__thread_stopper.is_set():
                 break
             self.__thread_stopper.wait(utils.get_sleep_seconds(self._next_time))
 
-        message = "\n\n––––––––––––––––––––––\n\n".join(self.__queue)
+        message = "\n\n".join(self.__queue)
         if self.player_name:
-            message = f"Player *{self.player_name}*\n" + message
+            message = f"Player *{self.player_name}*\n\n" + message
         response = post(self.api_url, json=dict(chat_id=self.chat_id, text=message, parse_mode="Markdown"))
         self._last_time = utils.now()
         if response.json().get('ok'):
@@ -1024,3 +1051,27 @@ class OfferItem(NamedTuple):
     amount: int = 0
     offer_id: int = 0
     citizen_id: int = 0
+
+
+class Inventory:
+    final: types.InvFinal
+    active: types.InvFinal
+    boosters: types.InvBooster
+    raw: types.InvRaw
+    market: types.InvRaw
+    used: int
+    total: int
+
+    def __init__(self):
+        self.active = {}
+        self.final = {}
+        self.boosters = {}
+        self.raw = {}
+        self.offers = {}
+        self.used = 0
+        self.total = 0
+
+    @property
+    def as_dict(self) -> Dict[str, Union[types.InvFinal, types.InvRaw, int]]:
+        return dict(active=self.active, final=self.final, boosters=self.boosters, raw=self.raw, offers=self.offers,
+                    total=self.total, used=self.used)

erepublik/types.py

@@ -0,0 +1,7 @@
+from datetime import datetime
+from typing import Dict, List, Union
+
+InvFinalItem = Dict[str, Union[str, int, List[Dict[str, Union[int, datetime]]]]]
+InvBooster = Dict[str, Dict[int, Dict[int, InvFinalItem]]]
+InvFinal = Dict[str, Dict[int, InvFinalItem]]
+InvRaw = Dict[str, Dict[int, Dict[str, Union[str, int]]]]

erepublik/utils.py

@@ -10,8 +10,9 @@ import unicodedata
 import warnings
 from decimal import Decimal
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Union
 
+import pytz
 import requests
 
 from . import __version__, constants
@@ -25,11 +26,8 @@ __all__ = ['VERSION', 'calculate_hit', 'caught_error', 'date_from_eday', 'eday_f
            'get_air_hit_dmg_value', 'get_file', 'get_ground_hit_dmg_value', 'get_sleep_seconds', 'good_timedelta',
            'interactive_sleep', 'json', 'localize_dt', 'localize_timestamp', 'normalize_html_json', 'now',
            'process_error', 'process_warning', 'send_email', 'silent_sleep', 'slugify', 'write_file', 'write_request',
-           'write_interactive_log', 'write_silent_log', 'get_final_hit_dmg', 'wait_for_lock']
+           'write_interactive_log', 'write_silent_log', 'get_final_hit_dmg', 'wait_for_lock',
-
+           'json_decode_object_hook', 'json_load', 'json_loads']
-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__
 
@@ -64,7 +62,9 @@ def good_timedelta(dt: datetime.datetime, td: datetime.timedelta) -> datetime.da
     return constants.erep_tz.normalize(dt + td)
 
 
-def eday_from_date(date: Union[datetime.date, datetime.datetime] = now()) -> int:
+def eday_from_date(date: Union[datetime.date, datetime.datetime] = None) -> int:
+    if date is None:
+        date = now()
     if isinstance(date, datetime.date):
         date = datetime.datetime.combine(date, datetime.time(0, 0, 0))
     return (date - datetime.datetime(2007, 11, 20, 0, 0, 0)).days
@@ -232,8 +232,8 @@ def send_email(name: str, content: List[Any], player=None, local_vars: Dict[str,
         if isinstance(local_vars.get('citizen'), Citizen):
             local_vars['citizen'] = repr(local_vars['citizen'])
 
-        from erepublik.classes import MyJSONEncoder
+        from erepublik.classes import ErepublikJSONEncoder
-        files.append(('file', ("local_vars.json", json.dumps(local_vars, cls=MyJSONEncoder),
+        files.append(('file', ("local_vars.json", json.dumps(local_vars, cls=ErepublikJSONEncoder),
                                "application/json")))
     if isinstance(player, Citizen):
         files.append(('file', ("instance.json", player.to_json(indent=True), "application/json")))
@@ -253,7 +253,7 @@ def caught_error(e: Exception):
 
 
 def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commit_id: str = None,
-                  interactive: Optional[bool] = None):
+                  interactive: bool = None):
     """
     Process error logging and email sending to developer
     :param interactive: Should print interactively
@@ -377,11 +377,6 @@ def get_final_hit_dmg(base_dmg: Union[Decimal, float, str], rang: int,
         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)
@@ -404,4 +399,38 @@ def wait_for_lock(function):
                 raise e
             instance.concurrency_available.set()
             return ret
+
     return wrapper
+
+
+def json_decode_object_hook(
+    o: Union[Dict[str, Any], List[Any], int, float, str]
+) -> Union[Dict[str, Any], List[Any], int, float, str, datetime.date, datetime.datetime, datetime.timedelta]:
+    """ Convert classes.ErepublikJSONEncoder datetime, date and timedelta to their python objects
+
+    :param o:
+    :return: Union[Dict[str, Any], List[Any], int, float, str, datetime.date, datetime.datetime, datetime.timedelta]
+    """
+    if o.get('__type__'):
+        _type = o.get('__type__')
+        if _type == 'datetime':
+            dt = datetime.datetime.strptime(f"{o['date']} {o['time']}", "%Y-%m-%d %H:%M:%S")
+            if o.get('tzinfo'):
+                dt = pytz.timezone(o['tzinfo']).localize(dt)
+            return dt
+        elif _type == 'date':
+            dt = datetime.datetime.strptime(f"{o['date']}", "%Y-%m-%d")
+            return dt.date()
+        elif _type == 'timedelta':
+            return datetime.timedelta(seconds=o['total_seconds'])
+    return o
+
+
+def json_load(f, **kwargs):
+    kwargs.update(object_hook=json_decode_object_hook)
+    return json.load(f, **kwargs)
+
+
+def json_loads(s: str, **kwargs):
+    kwargs.update(object_hook=json_decode_object_hook)
+    return json.loads(s, **kwargs)

requirements_dev.txt

@@ -1,18 +1,19 @@
 bump2version==1.0.1
-coverage==5.3
+coverage==5.3.1
-edx-sphinx-theme==1.5.0
+edx-sphinx-theme==1.6.1
 flake8==3.8.4
 ipython>=7.19.0
-isort==5.6.4
+isort==5.7.0
 pip==20.3.3
-PyInstaller==4.1
+pre-commit==2.9.3
-pytz==2020.4
-pytest==6.2.1
-responses==0.12.1
-setuptools==51.0.0
-Sphinx==3.3.1
-requests>=2.24.0,<2.26.0
-PySocks==1.7.1
-twine==3.2.0
-wheel==0.36.2
 pur==5.3.0
+PyInstaller==4.2
+PySocks==1.7.1
+pytest==6.2.1
+pytz>=2020.5
+requests>=2.25.1
+responses==0.12.1
+setuptools==51.3.3
+Sphinx==3.4.3
+twine==3.3.0
+wheel==0.36.2

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.23.3.4
+current_version = 0.23.4.13
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)\.?(?P<dev>\d+)?
@@ -37,4 +37,3 @@ warn_unused_configs = True
 [isort]
 multi_line_output = 2
 line_length = 120
-not_skip = __init__.py

setup.py

@@ -12,7 +12,7 @@ with open('HISTORY.rst') as history_file:
     history = history_file.read()
 
 requirements = [
-    'pytz==2020.4',
+    'pytz>=2020.0',
     'requests>=2.24.0,<2.26.0',
     'PySocks==1.7.1'
 ]
@@ -50,6 +50,6 @@ setup(
     test_suite='tests',
     tests_require=test_requirements,
     url='https://github.com/eeriks/erepublik/',
-    version='0.23.3.4',
+    version='0.23.4.13',
     zip_safe=False,
 )