Bump version: 0.25.1 → 0.25.1.1

# Conflicts:
#	erepublik/__init__.py
#	setup.cfg
#	setup.py

.editorconfig

@@ -21,6 +21,7 @@ insert_final_newline = false
 indent_style = tab
 
 [*.py]
+max_line_length = 240
 line_length=120
 multi_line_output=0
 balanced_wrapping=True

.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.8

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.utils module
+----------------------
+
+.. automodule:: erepublik.utils
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+erepublik.ws module
+-------------------
+
+.. automodule:: erepublik.ws
+   :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,9 +4,8 @@
 
 __author__ = """Eriks Karls"""
 __email__ = 'eriks@72.lv'
-__version__ = '0.23.4.1'
+__version__ = '0.25.1.1'
 
-from erepublik import classes, constants, utils
 from erepublik.citizen import Citizen
 
-__all__ = ["classes", "utils", "Citizen", 'constants']
+__all__ = ['Citizen', '__version__']

erepublik/_logging.py

@@ -0,0 +1,201 @@
+import base64
+import datetime
+import inspect
+import logging
+import os
+import sys
+import weakref
+from logging import LogRecord, handlers
+from pathlib import Path
+from typing import Any, Dict, Union
+
+import requests
+
+from erepublik.classes import Reporter
+from erepublik.constants import erep_tz
+from erepublik.utils import json, json_dumps, json_loads, slugify
+
+
+class ErepublikFileHandler(handlers.TimedRotatingFileHandler):
+    _file_path: Path
+
+    def __init__(self, filename: str = 'log/erepublik.log', *args, **kwargs):
+        log_path = Path(filename)
+        self._file_path = log_path
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        at_time = erep_tz.localize(datetime.datetime.now()).replace(hour=0, minute=0, second=0, microsecond=0)
+        kwargs.update(atTime=at_time)
+        super().__init__(filename, when='d', *args, **kwargs)
+
+    def doRollover(self) -> None:
+        self._file_path.parent.mkdir(parents=True, exist_ok=True)
+        super().doRollover()
+
+    def emit(self, record: LogRecord) -> None:
+        self._file_path.parent.mkdir(parents=True, exist_ok=True)
+        super().emit(record)
+
+
+class ErepublikLogConsoleHandler(logging.StreamHandler):
+    def __init__(self, *_):
+        super().__init__(sys.stdout)
+
+
+class ErepublikFormatter(logging.Formatter):
+    """override logging.Formatter to use an aware datetime object"""
+
+    dbg_fmt = "[%(asctime)s] DEBUG: %(module)s: %(lineno)d: %(msg)s"
+    info_fmt = "[%(asctime)s] %(msg)s"
+    default_fmt = "[%(asctime)s] %(levelname)s: %(msg)s"
+
+    def converter(self, timestamp: Union[int, float]) -> datetime.datetime:
+        return datetime.datetime.fromtimestamp(timestamp).astimezone(erep_tz)
+
+    def format(self, record: logging.LogRecord) -> str:
+        """
+        Format the specified record as text.
+
+        The record's attribute dictionary is used as the operand to a
+        string formatting operation which yields the returned string.
+        Before formatting the dictionary, a couple of preparatory steps
+        are carried out. The message attribute of the record is computed
+        using LogRecord.getMessage(). If the formatting string uses the
+        time (as determined by a call to usesTime(), formatTime() is
+        called to format the event time. If there is exception information,
+        it is formatted using formatException() and appended to the message.
+        """
+        if record.levelno == logging.DEBUG:
+            self._fmt = self.dbg_fmt
+        elif record.levelno == logging.INFO:
+            self._fmt = self.info_fmt
+        else:
+            self._fmt = self.default_fmt
+        self._style = logging.PercentStyle(self._fmt)
+
+        record.message = record.getMessage()
+        if self.usesTime():
+            record.asctime = self.formatTime(record, self.datefmt)
+        s = self.formatMessage(record)
+        if record.exc_info:
+            # Cache the traceback text to avoid converting it multiple times
+            # (it's constant anyway)
+            if not record.exc_text:
+                record.exc_text = self.formatException(record.exc_info)
+        return s
+
+    def formatTime(self, record, datefmt=None):
+        dt = self.converter(record.created)
+        if datefmt:
+            s = dt.strftime(datefmt)
+        else:
+            s = dt.strftime('%Y-%m-%d %H:%M:%S')
+        return s
+
+    def usesTime(self):
+        return self._style.usesTime()
+
+
+class ErepublikErrorHTTTPHandler(handlers.HTTPHandler):
+    def __init__(self, reporter: Reporter):
+        logging.Handler.__init__(self, level=logging.ERROR)
+        self._reporter = weakref.ref(reporter)
+        self.host = 'erep.lv'
+        self.url = '/ebot/error/'
+        self.method = 'POST'
+        self.secure = True
+        self.credentials = (str(reporter.citizen_id), reporter.key)
+        self.context = None
+
+    @property
+    def reporter(self):
+        return self._reporter()
+
+    def _get_last_response(self) -> Dict[str, str]:
+        response = self.reporter.citizen.r
+        url = response.url
+        last_index = url.index("?") if "?" in url else len(response.url)
+
+        name = slugify(response.url[len(self.reporter.citizen.url):last_index])
+        html = response.text
+
+        try:
+            json_loads(html)
+            ext = 'json'
+        except json.decoder.JSONDecodeError:
+            ext = 'html'
+        try:
+            resp_time = datetime.datetime.strptime(
+                response.headers.get('date'), '%a, %d %b %Y %H:%M:%S %Z'
+            ).replace(tzinfo=datetime.timezone.utc).astimezone(erep_tz).strftime('%F_%H-%M-%S')
+        except:
+            resp_time = slugify(response.headers.get('date'))
+        return dict(name=f"{resp_time}_{name}.{ext}", content=html.encode('utf-8'),
+                    mimetype="application/json" if ext == 'json' else "text/html")
+
+    def _get_local_vars(self) -> str:
+        trace = inspect.trace()
+        local_vars = {}
+        if trace:
+            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:
+            stack = inspect.stack()
+            report_error_caller_found = False
+            for frame in stack:
+                if report_error_caller_found:
+                    local_vars = frame.frame.f_locals
+                    break
+                if 'report_error' in str(frame.frame):
+                    report_error_caller_found = True
+
+        if 'state_thread' in local_vars:
+            local_vars.pop('state_thread', None)
+        from erepublik import Citizen
+        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'])
+        return json_dumps(local_vars)
+
+    def _get_instance_json(self) -> str:
+        if self.reporter:
+            return self.reporter.citizen.to_json(False)
+        return ""
+
+    def mapLogRecord(self, record: logging.LogRecord) -> Dict[str, Any]:
+        data = super().mapLogRecord(record)
+
+        # Log last response
+        resp = self._get_last_response()
+        files = [('file', (resp.get('name'), resp.get('content'), resp.get('mimetype'))), ]
+
+        files += list(('file', (f, open(f'log/{f}', 'rb'))) for f in os.listdir('log') if f.endswith('.log'))
+        local_vars_json = self._get_local_vars()
+        if local_vars_json:
+            files.append(('file', ('local_vars.json', local_vars_json, "application/json")))
+        instance_json = self._get_instance_json()
+        if instance_json:
+            files.append(('file', ('instance.json', instance_json, "application/json")))
+        data.update(files=files)
+        return data
+
+    def emit(self, record):
+        """
+        Emit a record.
+
+        Send the record to the Web server as a percent-encoded dictionary
+        """
+        try:
+            proto = 'https' if self.secure else 'http'
+            u, p = self.credentials
+            s = 'Basic ' + base64.b64encode(f'{u}:{p}'.encode('utf-8')).strip().decode('ascii')
+            headers = {'Authorization': s}
+            data = self.mapLogRecord(record)
+            files = data.pop('files') if 'files' in data else None
+            requests.post(f"{proto}://{self.host}{self.url}", headers=headers, data=data, files=files)
+        except Exception:
+            self.handleError(record)

erepublik/_types.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Dict, Union, List
+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]]]

erepublik/access_points.py

@@ -1,11 +1,13 @@
 import datetime
+import hashlib
 import random
 import time
 from typing import Any, Dict, List, Mapping, Union
 
 from requests import Response, Session
+from requests_toolbelt.utils import dump
 
-from . import constants, utils
+from erepublik import constants, utils
 
 __all__ = ['SlowRequests', 'CitizenAPI']
 
@@ -13,49 +15,29 @@ __all__ = ['SlowRequests', 'CitizenAPI']
 class SlowRequests(Session):
     last_time: datetime.datetime
     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',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',
-        '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: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: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.get_random_user_agent())
         self.request_log_name = utils.get_file(utils.now().strftime("debug/requests_%Y-%m-%d.log"))
         self.last_time = utils.now()
-        self.headers.update({
-            'User-Agent': random.choice(self.uas)
-        })
+        self.headers.update({'User-Agent': user_agent})
+        self.hooks["response"] = [self._log_response]
 
     @property
     def as_dict(self):
-        return dict(last_time=self.last_time, timeout=self.timeout, user_agent=self.headers['User-Agent'],
-                    request_log_name=self.request_log_name, debug=self.debug)
+        return dict(last_time=self.last_time, timeout=self.timeout, cookies=self.cookies.get_dict(), 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()
         self._log_request(url, method, **kwargs)
         resp = super().request(method, url, *args, **kwargs)
-        self._log_response(url, resp)
+        # self._log_response(resp)
         return resp
 
     def _slow_down_requests(self):
@@ -73,41 +55,74 @@ class SlowRequests(Session):
                 args.update({'kwargs': kwargs})
 
             if data:
-                args.update({"data": data})
+                args.update({'data': data})
 
             if json:
-                args.update({"json": json})
+                args.update({'json': json})
 
             if params:
-                args.update({"params": params})
+                args.update({'params': params})
 
             body = f"[{utils.now().strftime('%F %T')}]\tURL: '{url}'\tMETHOD: {method}\tARGS: {args}\n"
             with open(self.request_log_name, 'ab') as file:
                 file.write(body.encode("UTF-8"))
-            pass
 
-    def _log_response(self, url, resp, redirect: bool = False):
-        from erepublik import Citizen
+    def _log_response(self, response: Response, *args, **kwargs):
+        redirect = kwargs.get('redirect')
+        url = response.request.url
         if self.debug:
-            if resp.history and not redirect:
-                for hist_resp in resp.history:
-                    self._log_request(hist_resp.request.url, "REDIRECT")
-                    self._log_response(hist_resp.request.url, hist_resp, redirect=True)
+            if response.history and not redirect:
+                for hist_resp in response.history:
+                    self._log_request(hist_resp.request.url, 'REDIRECT')
+                    self._log_response(hist_resp, redirect=True)
 
             fd_path = 'debug/requests'
             fd_time = self.last_time.strftime('%Y/%m/%d/%H-%M-%S')
-            fd_name = utils.slugify(url[len(Citizen.url):])
-            fd_extra = "_REDIRECT" if redirect else ""
+            fd_name = utils.slugify(url[len(CitizenBaseAPI.url):])
+            fd_extra = '_REDIRECT' if redirect else ""
 
             try:
-                utils.json.loads(resp.text)
+                utils.json.loads(response.text)
                 fd_ext = 'json'
             except utils.json.JSONDecodeError:
                 fd_ext = 'html'
 
             filename = f'{fd_path}/{fd_time}_{fd_name}{fd_extra}.{fd_ext}'
-            utils.write_file(filename, resp.text)
-        pass
+            utils.write_file(filename, response.text)
+
+            if not redirect:
+                data = dump.dump_all(response)
+                utils.write_file(f'debug/dumps/{fd_time}_{fd_name}{fd_extra}.{fd_ext}.dump', data.decode('utf8'))
+
+    @staticmethod
+    def get_random_user_agent() -> str:
+        windows_x64 = 'Windows NT 10.0; Win64; x64'
+        linux_x64 = 'X11; Linux x86_64'
+        android_11 = 'Android 11; Mobile'
+        android_10 = 'Android 10; Mobile'
+        android_9 = 'Android 9; Mobile'
+
+        firefox_tmplt = 'Mozilla/5.0 ({osystem}; rv:{version}.0) Gecko/20100101 Firefox/{version}.0'
+        ff_version = range(85, 92)
+
+        chrome_tmplt = 'Mozilla/5.0 ({osystem}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{version} Safari/537.36'
+        chrome_version = ['85.0.4183.121',
+                          '86.0.4240.183',
+                          '87.0.4280.141',
+                          '88.0.4324.182',
+                          '89.0.4389.128',
+                          '90.0.4430.18',
+                          '91.0.4472.73',
+                          '92.0.4515.14']
+        uas = []
+
+        for osystem in [windows_x64, linux_x64, android_9, android_10, android_11]:
+            for version in ff_version:
+                uas.append(firefox_tmplt.format(osystem=osystem, version=version))
+            for version in chrome_version:
+                uas.append(chrome_tmplt.format(osystem=osystem, version=version))
+
+        return random.choice(uas)
 
 
 class CitizenBaseAPI:
@@ -120,6 +135,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)
 
@@ -134,13 +153,47 @@ class CitizenBaseAPI:
         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}'
+        url = f'http://{username}:{password}@{host}:{port}' if username and password else f'http://{host}:{port}'
         self._req.proxies = dict(http=url)
 
+    def _get_main_session_captcha(self) -> Response:
+        return self.get(f'{self.url}/main/sessionCaptcha')
+
+    def _get_main_session_unlock_popup(self) -> Response:
+        return self.get(f'{self.url}/main/sessionUnlockPopup')
+
+    def _post_main_session_get_challenge(self, captcha_id: int, image_id: str = "") -> Response:
+        c = [cookie.name for cookie in self._req.cookies if not cookie.has_nonstandard_attr('HttpOnly')]
+        env = dict(l=['tets'], s=[], c=c, m=0)
+        data = dict(_token=self.token, captchaId=captcha_id, env=utils.b64json(env))
+        if image_id:
+            data.update(imageId=image_id, isRefresh=True)
+        return self.post(f'{self.url}/main/sessionGetChallenge', data=data)
+
+    def _post_main_session_unlock(
+        self, captcha_id: int, image_id: str, challenge_id: str, coords: List[Dict[str, int]], src: str
+    ) -> Response:
+        c = [cookie.name for cookie in self._req.cookies if not cookie.has_nonstandard_attr('HttpOnly')]
+        env = dict(l=['tets'], s=[], c=c, m=0)
+        cookies = dict(sh=hashlib.sha256(','.join(env['l']+env['s']).encode('utf8')).hexdigest(),
+                       ch=hashlib.sha256(','.join(env['c']).encode('utf8')).hexdigest())
+        cookie_kwargs = dict(expires=int(time.time())+120, path="/en/main/sessionUnlock", domain='.www.erepublik.com',
+                             secure=True, rest={'HttpOnly': True})
+        self._req.cookies.set('sh', cookies['sh'], **cookie_kwargs)
+        self._req.cookies.set('ch', cookies['ch'], **cookie_kwargs)
+        b64_env = utils.b64json(env)
+        data = dict(_token=self.token, captchaId=captcha_id, imageId=image_id, challengeId=challenge_id,
+                    clickMatrix=utils.json_dumps(coords).replace(' ', ''), isMobile=0, env=b64_env, src=src)
+        return self.post(f'{self.url}/main/sessionUnlock', data=data, json=data,
+                         headers={'X-Requested-With': 'XMLHttpRequest', 'Referer': 'https://www.erepublik.com/en'})
+
+    def _post_energy_refill_get_inventory(self):
+        return self.post(f'{self.url}/economy/energyRefill-getInventory', data={'_token': self.token})
+
 
 class ErepublikAnniversaryAPI(CitizenBaseAPI):
     def _post_main_collect_anniversary_reward(self) -> Response:
-        return self.post(f"{self.url}/main/collect-anniversary-reward", 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:
@@ -151,7 +204,7 @@ class ErepublikAnniversaryAPI(CitizenBaseAPI):
         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}
+        data = {'nodeId': node_id, '_token': self.token, 'currencyCost': currency_amount}
         return self.post(f"{self.url}/main/map-rewards-speedup", data=data)
 
     def _post_map_rewards_claim(self, node_id: int, extra: bool = False) -> Response:
@@ -161,7 +214,7 @@ class ErepublikAnniversaryAPI(CitizenBaseAPI):
         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}/main/wheeloffortune-spin", data={'_token': self.token, "_currentCost": 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}/main/wheeloffortune-build", data={'_token': self.token})
@@ -183,7 +236,7 @@ class ErepublikArticleAPI(CitizenBaseAPI):
     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})
+            data.update({'parentId': parent})
         return self.post(f"{self.url}/main/articleComments/create", data=data)
 
     def _post_main_donate_article(self, article_id: int, amount: int) -> Response:
@@ -202,13 +255,13 @@ class ErepublikArticleAPI(CitizenBaseAPI):
 
 class ErepublikCompanyAPI(CitizenBaseAPI):
     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)
+        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_id: int, building_type: int = 1) -> Response:
-        data = {"_token": self.token, "company[industry_id]": industry_id, "company[building_type]": building_type}
+        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"})
+                         headers={'Referer': f"{self.url}/economy/create-company"})
 
     def _get_economy_inventory_items(self) -> Response:
         return self.get(f"{self.url}/economy/inventory-items/")
@@ -229,12 +282,12 @@ class ErepublikCompanyAPI(CitizenBaseAPI):
         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)
+        data = dict(_token=self.token, type='upgrade', companyId=factory, level=level, pin="" if pin is None else pin)
         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)
-        if action_type == "production":
+        if action_type == 'production':
             if employ is None:
                 employ = {}
             if wam is None:
@@ -257,7 +310,7 @@ class ErepublikCompanyAPI(CitizenBaseAPI):
         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)
+        data = dict(action_type='workOvertime', _token=self.token)
         return self.post(f"{self.url}/economy/workOvertime", data=data)
 
     def _post_economy_job_market_apply(self, citizen_id: int, salary: float) -> Response:
@@ -267,16 +320,16 @@ class ErepublikCompanyAPI(CitizenBaseAPI):
     def _post_economy_resign(self) -> Response:
         return self.post(f"{self.url}/economy/resign",
                          headers={"Content-Type": "application/x-www-form-urlencoded"},
-                         data={"_token": self.token, "action_type": "resign"})
+                         data={'_token': self.token, 'action_type': 'resign'})
 
     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"})
+            data.update({'sell': 'sell'})
         else:
-            data.update({"dissolve": factory_id})
+            data.update({'dissolve': factory_id})
         return self.post(f"{self.url}/economy/sell-company/{factory_id}",
-                         data=data, headers={"Referer": self.url})
+                         data=data, headers={'Referer': self.url})
 
 
 class ErepublikCountryAPI(CitizenBaseAPI):
@@ -287,7 +340,7 @@ class ErepublikCountryAPI(CitizenBaseAPI):
                                   quality: int = None) -> Response:
         data = dict(countryId=country_id, action=action, _token=self.token, value=value, quality=quality)
         return self.post(f"{self.url}/main/country-donate", data=data,
-                         headers={"Referer": f"{self.url}/country/economy/Latvia"})
+                         headers={'Referer': f"{self.url}/country/economy/Latvia"})
 
 
 class ErepublikEconomyAPI(CitizenBaseAPI):
@@ -305,24 +358,24 @@ 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,
                                           quality: int) -> Response:
         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}"})
+                         headers={'Referer': f"{self.url}/economy/donate-items/{citizen_id}"})
 
     def _post_economy_donate_money_action(self, citizen_id: int, amount: float = 0.0,
                                           currency: int = 62) -> Response:
         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}"})
+                         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)
@@ -340,19 +393,19 @@ class ErepublikEconomyAPI(CitizenBaseAPI):
     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)
+                    orderBy='price_asc' if order_asc else 'price_desc', _token=self.token)
         return self.post(f"{self.url}/economy/marketplaceAjax", data=data)
 
     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)
+                        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'],
+            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')
+            data = dict(_token=self.token, offerId=kwargs['offer_id'], sellAction='deleteOffer')
         else:
             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)
@@ -380,7 +433,7 @@ class ErepublikLocationAPI(CitizenBaseAPI):
     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(f"{self.url}/main/city-data/{city_id}/residents", params={"currentPage": page, **params})
+        return self.get(f"{self.url}/main/city-data/{city_id}/residents", params={'currentPage': page, **params})
 
 
 class ErepublikMilitaryAPI(CitizenBaseAPI):
@@ -403,7 +456,7 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
         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}
+        params = {'groupId': unit_id, 'panel': 'members', **kwargs}
         return self.get(f"{self.url}/military/military-unit-data/", params=params)
 
     def _post_main_activate_battle_effect(self, battle_id: int, kind: str, citizen_id: int) -> Response:
@@ -414,8 +467,10 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
         data = dict(_token=self.token, sideCountryId=side_id, battleId=battle_id)
         return self.post(f"{self.url}/main/battlefieldTravel", data=data)
 
-    def _post_main_battlefield_change_division(self, battle_id: int, division_id: int) -> Response:
+    def _post_main_battlefield_change_division(self, battle_id: int, division_id: int, side_id: int = None) -> Response:
         data = dict(_token=self.token, battleZoneId=division_id, battleId=battle_id)
+        if side_id is not None:
+            data.update(sideCountryId=side_id)
         return self.post(f"{self.url}/main/battlefieldTravel", data=data)
 
     def _get_wars_show(self, war_id: int) -> Response:
@@ -431,10 +486,10 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
 
     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)
-        if action == "battleStatistics":
-            data.update(round=kwargs["round_id"], zoneId=kwargs["round_id"], leftPage=page, rightPage=page,
-                        division=kwargs["division"], type=kwargs.get("type", 'damage'), )
-        elif action == "warList":
+        if action == 'battleStatistics':
+            data.update(round=kwargs['round_id'], zoneId=kwargs['round_id'], leftPage=page, rightPage=page,
+                        division=kwargs['division'], type=kwargs.get('type', 'damage'), )
+        elif action == 'warList':
             data.update(page=page)
         return self.post(f"{self.url}/military/battle-console", data=data)
 
@@ -451,9 +506,24 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
         data = dict(sideId=side_id, battleId=battle_id, _token=self.token, battleZoneId=zone_id)
         return self.post(f"{self.url}/military/fight-shooot/{battle_id}", data=data)
 
-    def _post_fight_deploy_deploy_report_data(self, deployment_id: int):
+    def _post_fight_deploy_deploy_report_data(self, deployment_id: int) -> Response:
         data = dict(_token=self.token, deploymentId=deployment_id)
-        return self.post(f"{self.url}/military/fightDeploy-deployReportData", json=data)
+        return self.post(f"{self.url}/military/fightDeploy-deployReportData", data=data)
+
+    def _post_fight_deploy_get_inventory(self, battle_id: int, side_id: int, battle_zone_id: int) -> Response:
+        data = dict(_token=self.token, battleId=battle_id, sideCountryId=side_id, battleZoneId=battle_zone_id)
+        return self.post(f"{self.url}/military/fightDeploy-getInventory", data=data)
+
+    def _post_fight_deploy_start_deploy(
+        self, battle_id: int, side_id: int, battle_zone_id: int, energy: int, weapon: int, **kwargs
+    ) -> Response:
+        data = dict(_token=self.token, battleId=battle_id, battleZoneId=battle_zone_id, sideCountryId=side_id,
+                    weaponQuality=weapon, totalEnergy=energy, **kwargs)
+        return self.post(f"{self.url}/military/fightDeploy-startDeploy", data=data)
+
+    def _post_military_fight_deploy_deploy_report_data(self, deployment_id: int) -> Response:
+        data = dict(_token=self.token, deploymentId=deployment_id)
+        return self.post(f"{self.url}/military/fightDeploy-deployReportData", data=data)
 
 
 class ErepublikPoliticsAPI(CitizenBaseAPI):
@@ -514,10 +584,10 @@ class ErepublikProfileAPI(CitizenBaseAPI):
         return self.get(f"{self.url}/main/messages-paginated/{page}")
 
     def _get_main_money_donation_accept(self, donation_id: int) -> Response:
-        return self.get(f"{self.url}/main/money-donation/accept/{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(f"{self.url}/main/money-donation/reject/{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(f"{self.url}/main/notificationsAjax/community/{page}")
@@ -537,16 +607,16 @@ class ErepublikProfileAPI(CitizenBaseAPI):
     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")
         if add:
-            data.update({"action": "addFriend"})
+            data.update({'action': 'addFriend'})
         else:
-            data.update({"action": "removeFriend"})
+            data.update({'action': 'removeFriend'})
         return self.post(f"{self.url}/main/citizen-addRemoveFriend", data=data)
 
     def _post_main_daily_task_reward(self) -> Response:
         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}
+        data = {'_token': self.token, "delete_message[]": msg_id}
         return self.post(f"{self.url}/main/messages-delete", data)
 
     def _post_eat(self, color: str) -> Response:
@@ -558,7 +628,7 @@ class ErepublikProfileAPI(CitizenBaseAPI):
         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")
+        data = dict(_token=self.token, email=email, commit='Reset password')
         return self.post(f"{self.url}/forgot-password", data=data)
 
     def _post_login(self, email: str, password: str) -> Response:
@@ -566,19 +636,19 @@ class ErepublikProfileAPI(CitizenBaseAPI):
         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"}
+        data = {'_token': self.token, "delete_alerts[]": notification_ids, 'deleteAllAlerts': '1', 'delete': 'Delete'}
         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}
+        data = {'_token': self.token, "delete_alerts[]": notification_ids}
         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}
+        data = {'_token': self.token, "delete_alerts[]": notification_ids}
         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}
+        data = {'_token': self.token, "delete_alerts[]": notification_ids}
         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:
@@ -588,15 +658,19 @@ class ErepublikProfileAPI(CitizenBaseAPI):
         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)
+        data = dict(action='check', _token=self.token)
         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(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}
+        data = {'action': action, 'params': params, '_token': self.token}
         return self.post(f"{self.url}/main/profile-update", data=data)
 
 
@@ -613,73 +687,73 @@ class ErepublikWallPostAPI(CitizenBaseAPI):
     # ## Country
 
     def _post_main_country_comment_retrieve(self, post_id: int) -> Response:
-        data = {"_token": self.token, "postId": post_id}
+        data = {'_token': self.token, 'postId': post_id}
         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}
+        data = {'_token': self.token, 'postId': post_id, 'comment_message': comment_message}
         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}
+        data = {'_token': self.token, 'post_message': body, 'post_as': post_as}
         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}
+        data = {'_token': self.token, 'page': 1, 'switchedFrom': False}
         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}
+        data = {'_token': self.token, 'postId': post_id}
         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}
+        data = {'_token': self.token, 'postId': post_id, 'comment_message': comment_message}
         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}
+        data = {'_token': self.token, 'post_message': body, 'post_as': post_as}
         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}
+        data = {'_token': self.token, 'page': 1, 'switchedFrom': False}
         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}
+        data = {'_token': self.token, 'postId': post_id}
         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}
+        data = {'_token': self.token, 'postId': post_id, 'comment_message': comment_message}
         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}
+        data = {'_token': self.token, 'post_message': body}
         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}
+        data = {'_token': self.token, 'page': 1, 'switchedFrom': False}
         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}
+        data = {'_token': self.token, 'postId': post_id}
         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}
+        data = {'_token': self.token, 'postId': post_id, 'comment_message': comment_message}
         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}
+        data = {'_token': self.token, 'post_message': body}
         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}
+        data = {'_token': self.token, 'page': 1, 'switchedFrom': False}
         return self.post(f"{self.url}/main/wall-post/retrieve/json", data=data)
 
     # ## Medal posting

erepublik/classes.py

@@ -1,18 +1,20 @@
 import datetime
 import hashlib
 import threading
+import warnings
 import weakref
 from decimal import Decimal
-from typing import Any, Dict, Generator, Iterable, List, NamedTuple, NoReturn, Tuple, Union
+from io import BytesIO
+from typing import Any, Dict, Generator, Iterable, List, NamedTuple, NoReturn, Optional, Tuple, Union
 
-from requests import Response, Session, post
+from requests import HTTPError, Response, Session, post
 
-from . import constants, utils, types
+from erepublik import _types as types
+from erepublik import constants, utils
 
 __all__ = ['Battle', 'BattleDivision', 'BattleSide', 'Company', 'Config', 'Details', 'Energy', 'ErepublikException',
-           'ErepublikNetworkException', 'EnergyToFight',
-           'Holding', 'MyCompanies', 'MyJSONEncoder', 'OfferItem', 'Politics', 'Reporter', 'TelegramReporter',
-           'Inventory']
+           'ErepublikNetworkException', 'EnergyToFight', 'Holding', 'Inventory', 'MyCompanies', 'OfferItem', 'Politics',
+           'Reporter', 'TelegramReporter', ]
 
 
 class ErepublikException(Exception):
@@ -26,10 +28,18 @@ class ErepublikNetworkException(ErepublikException):
         self.request = request
 
 
+class CloudFlareSessionError(ErepublikNetworkException):
+    pass
+
+
+class CaptchaSessionError(ErepublikNetworkException):
+    pass
+
+
 class Holding:
     id: int
     region: int
-    companies: List["Company"]
+    companies: List['Company']
     name: str
     _citizen = weakref.ReferenceType
 
@@ -37,16 +47,16 @@ class Holding:
         self._citizen = weakref.ref(citizen)
         self.id: int = _id
         self.region: int = region
-        self.companies: List["Company"] = list()
+        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"
+                name += 'company'
             else:
-                name += "companies"
+                name += 'companies'
             self.name = name
 
     @property
@@ -54,20 +64,20 @@ class Holding:
         return len([1 for company in self.companies if company.wam_enabled and not company.already_worked])
 
     @property
-    def wam_companies(self) -> Iterable["Company"]:
+    def wam_companies(self) -> Iterable['Company']:
         return [company for company in self.companies if company.wam_enabled]
 
     @property
-    def employable_companies(self) -> Iterable["Company"]:
+    def employable_companies(self) -> Iterable['Company']:
         return [company for company in self.companies if company.preset_works]
 
-    def add_company(self, company: "Company") -> NoReturn:
+    def add_company(self, company: 'Company') -> NoReturn:
         self.companies.append(company)
         self.companies.sort()
 
     def get_wam_raw_usage(self) -> Dict[str, Decimal]:
-        frm = Decimal("0.00")
-        wrm = Decimal("0.00")
+        frm = Decimal('0.00')
+        wrm = Decimal('0.00')
         for company in self.wam_companies:
             if company.industry in [1, 7, 8, 9, 10, 11]:
                 frm += company.raw_usage
@@ -75,11 +85,11 @@ class Holding:
                 wrm += company.raw_usage
         return dict(frm=frm, wrm=wrm)
 
-    def get_wam_companies(self, raw_factory: bool = None) -> List["Company"]:
+    def get_wam_companies(self, raw_factory: bool = None) -> List['Company']:
         raw = []
         factory = []
         for company in self.wam_companies:
-            if not company.already_worked and not company.cannot_wam_reason == "war":
+            if not company.already_worked and not company.cannot_wam_reason == 'war':
                 if company.is_raw:
                     raw.append(company)
                 else:
@@ -93,9 +103,9 @@ class Holding:
         comp = len(self.companies)
         name = f"Holding (#{self.id}) with {comp} "
         if comp == 1:
-            name += "company"
+            name += 'company'
         else:
-            name += "companies"
+            name += 'companies'
         return name
 
     def __repr__(self):
@@ -147,10 +157,10 @@ class Company:
             self.raw_usage = - self.products_made * raw_usage
 
     def _get_real_quality(self, quality) -> int:
-        #  7: "FRM q1",  8: "FRM q2",  9: "FRM q3", 10: "FRM q4", 11: "FRM q5",
-        # 12: "WRM q1", 13: "WRM q2", 14: "WRM q3", 15: "WRM q4", 16: "WRM q5",
-        # 18: "HRM q1", 19: "HRM q2", 20: "HRM q3", 21: "HRM q4", 22: "HRM q5",
-        # 24: "ARM q1", 25: "ARM q2", 26: "ARM q3", 27: "ARM q4", 28: "ARM q5",
+        #  7: 'FRM q1',  8: 'FRM q2',  9: 'FRM q3', 10: 'FRM q4', 11: 'FRM q5',
+        # 12: 'WRM q1', 13: 'WRM q2', 14: 'WRM q3', 15: 'WRM q4', 16: 'WRM q5',
+        # 18: 'HRM q1', 19: 'HRM q2', 20: 'HRM q3', 21: 'HRM q4', 22: 'HRM q5',
+        # 24: 'ARM q1', 25: 'ARM q2', 26: 'ARM q3', 27: 'ARM q4', 28: 'ARM q5',
         if 7 <= self.industry <= 11:
             return self.industry % 6
         elif 12 <= self.industry <= 16:
@@ -164,10 +174,10 @@ class Company:
 
     @property
     def _internal_industry(self) -> int:
-        #  7: "FRM q1",  8: "FRM q2",  9: "FRM q3", 10: "FRM q4", 11: "FRM q5",
-        # 12: "WRM q1", 13: "WRM q2", 14: "WRM q3", 15: "WRM q4", 16: "WRM q5",
-        # 18: "HRM q1", 19: "HRM q2", 20: "HRM q3", 21: "HRM q4", 22: "HRM q5",
-        # 24: "ARM q1", 25: "ARM q2", 26: "ARM q3", 27: "ARM q4", 28: "ARM q5",
+        #  7: 'FRM q1',  8: 'FRM q2',  9: 'FRM q3', 10: 'FRM q4', 11: 'FRM q5',
+        # 12: 'WRM q1', 13: 'WRM q2', 14: 'WRM q3', 15: 'WRM q4', 16: 'WRM q5',
+        # 18: 'HRM q1', 19: 'HRM q2', 20: 'HRM q3', 21: 'HRM q4', 22: 'HRM q5',
+        # 24: 'ARM q1', 25: 'ARM q2', 26: 'ARM q3', 27: 'ARM q4', 28: 'ARM q5',
         if 7 <= self.industry <= 11:
             return 7
         elif 12 <= self.industry <= 16:
@@ -186,22 +196,22 @@ class Company:
     def __hash__(self):
         return hash(self._sort_keys)
 
-    def __lt__(self, other: "Company"):
+    def __lt__(self, other: 'Company'):
         return self._sort_keys < other._sort_keys
 
-    def __le__(self, other: "Company"):
+    def __le__(self, other: 'Company'):
         return self._sort_keys <= other._sort_keys
 
-    def __gt__(self, other: "Company"):
+    def __gt__(self, other: 'Company'):
         return self._sort_keys > other._sort_keys
 
-    def __ge__(self, other: "Company"):
+    def __ge__(self, other: 'Company'):
         return self._sort_keys >= other._sort_keys
 
-    def __eq__(self, other: "Company"):
+    def __eq__(self, other: 'Company'):
         return self._sort_keys == other._sort_keys
 
-    def __ne__(self, other: "Company"):
+    def __ne__(self, other: 'Company'):
         return self._sort_keys != other._sort_keys
 
     def __str__(self):
@@ -413,26 +423,35 @@ class Config:
 class Energy:
     limit = 500  # energyToRecover
     interval = 10  # energyPerInterval
-    recoverable = 0  # energyFromFoodRemaining
-    recovered = 0  # energy
+    energy = 0  # energy
     _recovery_time = None
 
     def __init__(self):
         self._recovery_time = utils.now()
 
     def __repr__(self):
-        return f"{self.recovered:4}/{self.limit:4} + {self.recoverable:4}, {self.interval:3}hp/6min"
+        return f"{self.energy:4}/{self.limit:4}, {self.interval:3}hp/6min"
+
+    @property
+    def recovered(self):
+        warnings.warn('Deprecated since auto auto-eat! Will be removed soon. Use Energy.energy', DeprecationWarning)
+        return self.energy
+
+    @property
+    def recoverable(self):
+        warnings.warn('Deprecated since auto auto-eat! Will be removed soon. Use Energy.energy', DeprecationWarning)
+        return 0
 
     def set_reference_time(self, recovery_time: datetime.datetime):
         self._recovery_time = recovery_time.replace(microsecond=0)
 
     @property
     def food_fights(self):
-        return self.available // 10
+        return self.energy // 10
 
     @property
     def reference_time(self):
-        if self.is_recovered_full or self._recovery_time < utils.now():
+        if self.is_energy_full or self._recovery_time < utils.now():
             ret = utils.now()
         else:
             ret = self._recovery_time
@@ -440,26 +459,28 @@ class Energy:
 
     @property
     def is_recoverable_full(self):
-        return self.recoverable >= self.limit - 5 * self.interval
+        warnings.warn('Deprecated since auto auto-eat! Will be removed soon. Use Energy.is_energy_full', DeprecationWarning)
+        return self.is_energy_full
 
     @property
     def is_recovered_full(self):
-        return self.recovered >= self.limit - self.interval
+        warnings.warn('Deprecated since auto auto-eat! Will be removed soon. Use Energy.is_energy_full', DeprecationWarning)
+        return self.is_energy_full
 
     @property
     def is_energy_full(self):
-        return self.is_recoverable_full and self.is_recovered_full
+        return self.energy >= self.limit - self.interval
 
     @property
     def available(self):
-        return self.recovered + self.recoverable
+        warnings.warn('Deprecated since auto auto-eat! Will be removed soon. Use Energy.energy', DeprecationWarning)
+        return self.energy
 
     @property
     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,
+        return dict(limit=self.limit, interval=self.interval, energy=self.energy,
                     reference_time=self.reference_time, food_fights=self.food_fights,
-                    is_recoverable_full=self.is_recoverable_full, is_recovered_full=self.is_recovered_full,
-                    is_energy_full=self.is_energy_full, available=self.available)
+                    is_energy_full=self.is_energy_full)
 
 
 class Details:
@@ -468,6 +489,7 @@ class Details:
     pp: int = 0
     pin: str = None
     gold: float = 0
+    level: int = 0
     next_pp: List[int] = None
     citizen_id: int = 0
     citizenship: constants.Country
@@ -482,6 +504,8 @@ class Details:
     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}
+        _default_country = constants.Country(0, 'Unknown', 'Unknown', 'XX')
+        self.citizenship = self.current_country = self.residence_country = _default_country
 
     @property
     def xp_till_level_up(self):
@@ -512,11 +536,15 @@ class Details:
     @property
     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,
-                    residence_country=self.residence_country, daily_task_done=self.daily_task_done,
-                    daily_task_reward=self.daily_task_reward, mayhem_skills=self.mayhem_skills,
-                    xp_till_level_up=self.xp_till_level_up)
+                    level=self.level, citizen_id=self.citizen_id, citizenship=self.citizenship,
+                    current_region=self.current_region, current_country=self.current_country,
+                    residence_region=self.residence_region, residence_country=self.residence_country,
+                    daily_task_done=self.daily_task_done, daily_task_reward=self.daily_task_reward,
+                    mayhem_skills=self.mayhem_skills, xp_till_level_up=self.xp_till_level_up)
+
+    @property
+    def is_elite(self):
+        return self.level > 100
 
 
 class Politics:
@@ -575,7 +603,7 @@ class Reporter:
         self._citizen = weakref.ref(citizen)
         self._req = Session()
         self.url = "https://api.erep.lv"
-        self._req.headers.update({"user-agent": "eRepublik Script Reporter v3",
+        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})
@@ -599,24 +627,36 @@ 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))
-                self._req.post(f"{self.url}/bot/update", json=unreported_data)
+                unreported_data = utils.json_loads(utils.json_dumps(unreported_data))
+                r = self._req.post(f"{self.url}/bot/update", json=unreported_data)
+                r.raise_for_status()
             self.__to_update.clear()
-        data = utils.json.loads(utils.json.dumps(data, cls=MyJSONEncoder))
+        data = utils.json.loads(utils.json_dumps(data))
         r = self._req.post(f"{self.url}/bot/update", json=data)
+        r.raise_for_status()
         return r
 
+    def _bot_update(self, data: Dict[str, Any]) -> Optional[Response]:
+        if not self.__registered:
+            self.do_init()
+        if self.allowed:
+            try:
+                return self.__bot_update(data)
+            except HTTPError:
+                self.__to_update.append(data)
+        else:
+            self.__to_update.append(data)
+
     def register_account(self):
         if not self.__registered:
-            try:
-                r = self.__bot_update(dict(key=self.key, check=True, player_id=self.citizen_id))
-                if not r.json().get("status"):
+            r = self.__bot_update(dict(key=self.key, check=True, player_id=self.citizen_id))
+            if r:
+                if not r.json().get('status'):
                     self._req.post(f"{self.url}/bot/register", json=dict(name=self.name, email=self.email,
                                                                          player_id=self.citizen_id))
-            finally:
                 self.__registered = True
                 self.allowed = True
-                self.report_action("STARTED", value=utils.now().strftime("%F %T"))
+                self.report_action('STARTED', value=utils.now().strftime("%F %T"))
 
     def send_state_update(self, xp: int, cc: float, gold: float, inv_total: int, inv: int,
                           hp_limit: int, hp_interval: int, hp_available: int, food: int, pp: int):
@@ -625,9 +665,7 @@ class Reporter:
             xp=xp, cc=cc, gold=gold, inv_total=inv_total, inv_free=inv_total - inv, inv=inv, food=food,
             pp=pp, hp_limit=hp_limit, hp_interval=hp_interval, hp_available=hp_available,
         ))
-
-        if self.allowed:
-            self.__bot_update(data)
+        self._bot_update(data)
 
     def report_action(self, action: str, json_val: Dict[Any, Any] = None, value: str = None):
         json_data = dict(
@@ -639,21 +677,28 @@ class Reporter:
             json_data['log'].update(dict(value=value))
         if not any([self.key, self.email, self.name, self.citizen_id]):
             return
-        if self.allowed:
-            self.__bot_update(json_data)
-        else:
-            self.__to_update.append(json_data)
+        self._bot_update(json_data)
 
-    def report_fighting(self, battle: "Battle", invader: bool, division: "BattleDivision", damage: float, hits: int):
+    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_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))
 
-    def fetch_battle_priorities(self, country: constants.Country) -> List["Battle"]:
+    def fetch_battle_priorities(self, country: constants.Country) -> List['Battle']:
         try:
             battle_response = self._req.get(f'{self.url}/api/v1/battles/{country.id}')
             return [self.citizen.all_battles[bid] for bid in battle_response.json().get('battle_ids', []) if
@@ -661,52 +706,28 @@ 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',
-                                          params=dict(citizen=self.citizen_id, key=self.key))
-            return task_response.json().get('task_collection')
+            task_response = self._req.post(
+                f'{self.url}/api/v1/command', data=dict(citizen=self.citizen_id, key=self.key)).json()
+            if task_response.get('status'):
+                return task_response.get('data')
+            else:
+                return []
         except:  # noqa
             return []
 
 
-class MyJSONEncoder(utils.json.JSONEncoder):
-    def default(self, o):
-        from erepublik.citizen import Citizen
-        if isinstance(o, Decimal):
-            return float(f"{o:.02f}")
-        elif isinstance(o, datetime.datetime):
-            return dict(__type__='datetime', date=o.strftime("%Y-%m-%d"), time=o.strftime("%H:%M:%S"),
-                        tzinfo=str(o.tzinfo) if o.tzinfo else None)
-        elif isinstance(o, datetime.date):
-            return dict(__type__='date', date=o.strftime("%Y-%m-%d"))
-        elif isinstance(o, datetime.timedelta):
-            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)
-        elif hasattr(o, 'as_dict'):
-            return o.as_dict
-        elif isinstance(o, set):
-            return list(o)
-        elif isinstance(o, Citizen):
-            return o.to_json()
-        try:
-            return super().default(o)
-        except Exception as e:  # noqa
-            return 'Object is not JSON serializable'
-
-
 class BattleSide:
     points: int
     deployed: List[constants.Country]
     allies: List[constants.Country]
-    battle: "Battle"
+    battle: 'Battle'
     _battle: weakref.ReferenceType
     country: constants.Country
     is_defender: bool
 
-    def __init__(self, battle: "Battle", country: constants.Country, points: int, allies: List[constants.Country],
+    def __init__(self, battle: 'Battle', country: constants.Country, points: int, allies: List[constants.Country],
                  deployed: List[constants.Country], defender: bool):
         self._battle = weakref.ref(battle)
         self.country = country
@@ -720,11 +741,11 @@ class BattleSide:
         return self.country.id
 
     def __repr__(self):
-        side_text = "Defender" if self.is_defender else "Invader "
+        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.is_defender else "Invader "
+        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):
@@ -750,7 +771,7 @@ class BattleDivision:
     inv_medal: Dict[str, int]
     terrain: int
     div: int
-    battle: "Battle"
+    battle: 'Battle'
     _battle: weakref.ReferenceType
 
     @property
@@ -766,7 +787,7 @@ class BattleDivision:
     def div_end(self) -> bool:
         return utils.now() >= self.end
 
-    def __init__(self, battle: "Battle", div_id: int, end: datetime.datetime, epic: bool, div: int, wall_for: int,
+    def __init__(self, battle: 'Battle', div_id: int, end: datetime.datetime, epic: bool, div: int, wall_for: int,
                  wall_dom: float, terrain_id: int = 0):
         """Battle division helper class
 
@@ -782,7 +803,7 @@ class BattleDivision:
         self.id = div_id
         self.end = end
         self.epic = epic
-        self.wall = dict({"for": wall_for, "dom": wall_dom})
+        self.wall = {'for': wall_for, 'dom': wall_dom}
         self.terrain = terrain_id
         self.div = div
 
@@ -795,7 +816,7 @@ class BattleDivision:
         if self.terrain:
             base_name += f" ({self.terrain_display})"
         if self.div_end:
-            base_name += " Ended"
+            base_name += ' Ended'
         return base_name
 
     def __repr__(self):
@@ -887,8 +908,8 @@ class Battle:
 
             battle_div = BattleDivision(self, div_id=data.get('id'), div=data.get('div'), end=end,
                                         epic=data.get('epic_type') in [1, 5],
-                                        wall_for=data.get('wall').get("for"),
-                                        wall_dom=data.get('wall').get("dom"),
+                                        wall_for=data.get('wall').get('for'),
+                                        wall_dom=data.get('wall').get('dom'),
                                         terrain_id=data.get('terrain', 0))
 
             self.div.update({div: battle_div})
@@ -968,13 +989,13 @@ class TelegramReporter:
         if token is None:
             token = "864251270:AAFzZZdjspI-kIgJVk4gF3TViGFoHnf8H4o"
         self.chat_id = chat_id
-        self.api_url = f"https://api.telegram.org/bot{token}/sendMessage"
+        self.api_url = f"https://api.telegram.org/bot{token}"
         self.player_name = player_name or ""
         self.__initialized = True
         self._last_time = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-5))
         self._last_full_energy_report = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-30))
         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)
@@ -1002,22 +1023,44 @@ 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
-        response = post(self.api_url, json=dict(chat_id=self.chat_id, text=message, parse_mode="Markdown"))
+            message = f"Player *{self.player_name}*\n\n" + message
+        response = post(f"{self.api_url}/sendMessage", json=dict(chat_id=self.chat_id, text=message, parse_mode='Markdown'))
         self._last_time = utils.now()
         if response.json().get('ok'):
             self.__queue.clear()
             return True
         return False
 
+    def send_photos(self, photos: List[Tuple[str, BytesIO]]):
+        for photo_title, photo in photos:
+            photo.seek(0)
+            post(f"https://{self.api_url}/sendPhoto",
+                 data=dict(chat_id=self.chat_id, caption=photo_title),
+                 files=[('photo', ("f{utils.slugify(photo_title)}.png", photo))])
+        return
+
 
 class OfferItem(NamedTuple):
     price: float = 999_999_999.

erepublik/constants.py

@@ -3,8 +3,8 @@ from typing import Dict, Optional, Union
 
 import pytz
 
-__all__ = ["erep_tz", 'min_datetime', "max_datetime", "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))
@@ -60,11 +60,11 @@ class Industries:
                  '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: "Weapon", 3: "Ticket", 4: "House", 23: "Aircraft",
-               7: "foodRaw", 8: "FRM q2", 9: "FRM q3", 10: "FRM q4", 11: "FRM 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"}
+    __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: '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]]:
         if isinstance(item, int):
@@ -81,24 +81,94 @@ class Industries:
         return dict(by_id=self.__by_id, by_name=self.__by_name)
 
 
-AIR_RANKS: Dict[int, str] = {
-    1: "Airman", 2: "Airman 1st Class", 3: "Airman 1st Class*", 4: "Airman 1st Class**", 5: "Airman 1st Class***",
-    6: "Airman 1st Class****", 7: "Airman 1st Class*****", 8: "Senior Airman", 9: "Senior Airman*",
-    10: "Senior Airman**", 11: "Senior Airman***", 12: "Senior Airman****", 13: "Senior Airman*****",
-    14: "Staff Sergeant", 15: "Staff Sergeant*", 16: "Staff Sergeant**", 17: "Staff Sergeant***",
-    18: "Staff Sergeant****", 19: "Staff Sergeant*****", 20: "Aviator", 21: "Aviator*", 22: "Aviator**",
-    23: "Aviator***", 24: "Aviator****", 25: "Aviator*****", 26: "Flight Lieutenant", 27: "Flight Lieutenant*",
-    28: "Flight Lieutenant**", 29: "Flight Lieutenant***", 30: "Flight Lieutenant****", 31: "Flight Lieutenant*****",
-    32: "Squadron Leader", 33: "Squadron Leader*", 34: "Squadron Leader**", 35: "Squadron Leader***",
-    36: "Squadron Leader****", 37: "Squadron Leader*****", 38: "Chief Master Sergeant", 39: "Chief Master Sergeant*",
-    40: "Chief Master Sergeant**", 41: "Chief Master Sergeant***", 42: "Chief Master Sergeant****",
-    43: "Chief Master Sergeant*****", 44: "Wing Commander", 45: "Wing Commander*", 46: "Wing Commander**",
-    47: "Wing Commander***", 48: "Wing Commander****", 49: "Wing Commander*****", 50: "Group Captain",
-    51: "Group Captain*", 52: "Group Captain**", 53: "Group Captain***", 54: "Group Captain****",
-    55: "Group Captain*****", 56: "Air Commodore", 57: "Air Commodore*", 58: "Air Commodore**", 59: "Air Commodore***",
-    60: "Air Commodore****", 61: "Air Commodore*****",
+class Rank:
+    id: int
+    name: str
+    rank_points: int
+    is_air: bool
+
+    def __init__(self, id: int, name: str, rank_points: int, is_air: bool = False):
+        self.id = id
+        self.name = name
+        self.rank_points = rank_points
+        self.is_air = bool(is_air)
+
+    def __int__(self):
+        return self.id
+
+    def __eq__(self, other):
+        if isinstance(other, Rank):
+            return self.id == other.id if other.is_air == self.is_air else False
+        else:
+            return self.id == int(other)
+
+    def __ne__(self, other):
+        if isinstance(other, Rank):
+            return not self.id == other.id if other.is_air == self.is_air else True
+        else:
+            return not self.id == int(other)
+
+    def __lt__(self, other):
+        if isinstance(other, Rank):
+            return self.id < other.id if other.is_air == self.is_air else False
+        else:
+            return self.id < int(other)
+
+    def __le__(self, other):
+        if isinstance(other, Rank):
+            return self.id <= other.id if other.is_air == self.is_air else False
+        else:
+            return self.id <= int(other)
+
+    def __gt__(self, other):
+        if isinstance(other, Rank):
+            return self.id > other.id if other.is_air == self.is_air else False
+        else:
+            return self.id > int(other)
+
+    def __ge__(self, other):
+        if isinstance(other, Rank):
+            return self.id >= other.id if other.is_air == self.is_air else False
+        else:
+            return self.id >= int(other)
+
+    @property
+    def as_dict(self):
+        return dict(id=self.id, name=self.name, rank_points=self.rank_points, is_air=self.is_air)
+
+    def __str__(self):
+        return f"{'Air' if self.is_air else 'Ground'}Rank<#{self.id} {self.name}>"
+
+    def __repr__(self):
+        return str(self)
+
+
+AIR_RANK_NAMES: Dict[int, str] = {
+    1: 'Airman', 2: 'Airman 1st Class', 3: 'Airman 1st Class*', 4: 'Airman 1st Class**', 5: 'Airman 1st Class***', 6: 'Airman 1st Class****', 7: 'Airman 1st Class*****',
+    8: 'Senior Airman', 9: 'Senior Airman*', 10: 'Senior Airman**', 11: 'Senior Airman***', 12: 'Senior Airman****', 13: 'Senior Airman*****',
+    14: 'Staff Sergeant', 15: 'Staff Sergeant*', 16: 'Staff Sergeant**', 17: 'Staff Sergeant***', 18: 'Staff Sergeant****', 19: 'Staff Sergeant*****',
+    20: 'Aviator', 21: 'Aviator*', 22: 'Aviator**', 23: 'Aviator***', 24: 'Aviator****', 25: 'Aviator*****',
+    26: 'Flight Lieutenant', 27: 'Flight Lieutenant*', 28: 'Flight Lieutenant**', 29: 'Flight Lieutenant***', 30: 'Flight Lieutenant****', 31: 'Flight Lieutenant*****',
+    32: 'Squadron Leader', 33: 'Squadron Leader*', 34: 'Squadron Leader**', 35: 'Squadron Leader***', 36: 'Squadron Leader****', 37: 'Squadron Leader*****',
+    38: 'Chief Master Sergeant', 39: 'Chief Master Sergeant*', 40: 'Chief Master Sergeant**', 41: 'Chief Master Sergeant***', 42: 'Chief Master Sergeant****', 43: 'Chief Master Sergeant*****',
+    44: 'Wing Commander', 45: 'Wing Commander*', 46: 'Wing Commander**', 47: 'Wing Commander***', 48: 'Wing Commander****', 49: 'Wing Commander*****',
+    50: 'Group Captain', 51: 'Group Captain*', 52: 'Group Captain**', 53: 'Group Captain***', 54: 'Group Captain****', 55: 'Group Captain*****',
+    56: 'Air Commodore', 57: 'Air Commodore*', 58: 'Air Commodore**', 59: 'Air Commodore***', 60: 'Air Commodore****', 61: 'Air Commodore*****',
+    62: 'Air Vice Marshal', 63: 'Air Vice Marshal*', 64: 'Air Vice Marshal**', 65: 'Air Vice Marshal***', 66: 'Air Vice Marshal****', 67: 'Air Vice Marshal*****',
+    68: 'Air Marshal', 69: 'Air Marshal*', 70: 'Air Marshal**', 71: 'Air Marshal***', 72: 'Air Marshal****', 73: 'Air Marshal*****',
+    74: 'Air Chief Marshal', 75: 'Air Chief Marshal*', 76: 'Air Chief Marshal**', 77: 'Air Chief Marshal***', 78: 'Air Chief Marshal****', 79: 'Air Chief Marshal*****',
 }
 
+AIR_RANK_POINTS: Dict[int, Optional[int]] = {
+    1: 0, 2: 10, 3: 25, 4: 45, 5: 70, 6: 100, 7: 140, 8: 190, 9: 270, 10: 380, 11: 530, 12: 850, 13: 1300, 14: 2340, 15: 3300, 16: 4200, 17: 5150, 18: 6100, 19: 7020, 20: 9100, 21: 12750, 22: 16400, 23: 20000, 24: 23650, 25: 27300,
+    26: 35500, 27: 48000, 28: 60000, 29: 72400, 30: 84500, 31: 97000, 32: 110000, 33: 140000, 34: 170000, 35: 210000, 36: 290000, 37: 350000, 38: 429000, 39: 601000, 40: 772000, 41: 944000, 42: 1115000, 43: 1287000,
+    44: 1673000, 45: 2238000, 46: 2804000, 47: 3369000, 48: 3935000, 49: 4500000, 50: 5020000, 51: 7028000, 52: 9036000, 53: 11044000, 54: 13052000, 55: 15060000,
+    56: 19580000, 57: 27412000, 58: 35244000, 59: 43076000, 60: 50908000, 61: 58740000, 62: 76360000, 63: 113166443, 64: 137448000, 65: None, 66: None, 67: None,
+    68: None, 69: None, 70: None, 71: None, 72: None, 73: None, 74: None, 75: None, 76: None, 77: None, 78: None, 79: None,
+}
+
+AIR_RANKS: Dict[int, Rank] = {i: Rank(i, AIR_RANK_NAMES[i], AIR_RANK_POINTS[i], True) for i in range(1, 80)}
+
 COUNTRIES: Dict[int, Country] = {
     1: Country(1, 'Romania', 'Romania', 'ROU'), 9: Country(9, 'Brazil', 'Brazil', 'BRA'),
     10: Country(10, 'Italy', 'Italy', 'ITA'), 11: Country(11, 'France', 'France', 'FRA'),
@@ -144,28 +214,18 @@ COUNTRIES: Dict[int, Country] = {
 
 FOOD_ENERGY: Dict[str, int] = dict(q1=2, q2=4, q3=6, q4=8, q5=10, q6=12, q7=20)
 
-GROUND_RANKS: Dict[int, str] = {
-    1: "Recruit", 2: "Private", 3: "Private*", 4: "Private**", 5: "Private***",
-    6: "Corporal", 7: "Corporal*", 8: "Corporal**", 9: "Corporal***",
-    10: "Sergeant", 11: "Sergeant*", 12: "Sergeant**", 13: "Sergeant***",
-    14: "Lieutenant", 15: "Lieutenant*", 16: "Lieutenant**", 17: "Lieutenant***",
-    18: "Captain", 19: "Captain*", 20: "Captain**", 21: "Captain***",
-    22: "Major", 23: "Major*", 24: "Major**", 25: "Major***",
-    26: "Commander", 27: "Commander*", 28: "Commander**", 29: "Commander***",
-    30: "Lt Colonel", 31: "Lt Colonel*", 32: "Lt Colonel**", 33: "Lt Colonel***",
-    34: "Colonel", 35: "Colonel*", 36: "Colonel**", 37: "Colonel***",
-    38: "General", 39: "General*", 40: "General**", 41: "General***",
-    42: "Field Marshal", 43: "Field Marshal*", 44: "Field Marshal**", 45: "Field Marshal***",
-    46: "Supreme Marshal", 47: "Supreme Marshal*", 48: "Supreme Marshal**", 49: "Supreme Marshal***",
-    50: "National Force", 51: "National Force*", 52: "National Force**", 53: "National Force***",
-    54: "World Class Force", 55: "World Class Force*", 56: "World Class Force**", 57: "World Class Force***",
-    58: "Legendary Force", 59: "Legendary Force*", 60: "Legendary Force**", 61: "Legendary Force***",
-    62: "God of War", 63: "God of War*", 64: "God of War**", 65: "God of War***",
-    66: "Titan", 67: "Titan*", 68: "Titan**", 69: "Titan***",
-    70: "Legends I", 71: "Legends II", 72: "Legends III", 73: "Legends IV", 74: "Legends V", 75: "Legends VI",
-    76: "Legends VII", 77: "Legends VIII", 78: "Legends IX", 79: "Legends X", 80: "Legends XI", 81: "Legends XII",
-    82: "Legends XIII", 83: "Legends XIV", 84: "Legends XV", 85: "Legends XVI", 86: "Legends XVII", 87: "Legends XVIII",
-    88: "Legends XIX", 89: "Legends XX",
+GROUND_RANK_NAMES: Dict[int, str] = {
+    1: 'Recruit', 2: 'Private', 3: 'Private*', 4: 'Private**', 5: 'Private***', 6: 'Corporal', 7: 'Corporal*', 8: 'Corporal**', 9: 'Corporal***',
+    10: 'Sergeant', 11: 'Sergeant*', 12: 'Sergeant**', 13: 'Sergeant***', 14: 'Lieutenant', 15: 'Lieutenant*', 16: 'Lieutenant**', 17: 'Lieutenant***',
+    18: 'Captain', 19: 'Captain*', 20: 'Captain**', 21: 'Captain***', 22: 'Major', 23: 'Major*', 24: 'Major**', 25: 'Major***',
+    26: 'Commander', 27: 'Commander*', 28: 'Commander**', 29: 'Commander***', 30: 'Lt Colonel', 31: 'Lt Colonel*', 32: 'Lt Colonel**', 33: 'Lt Colonel***',
+    34: 'Colonel', 35: 'Colonel*', 36: 'Colonel**', 37: 'Colonel***', 38: 'General', 39: 'General*', 40: 'General**', 41: 'General***',
+    42: 'Field Marshal', 43: 'Field Marshal*', 44: 'Field Marshal**', 45: 'Field Marshal***', 46: 'Supreme Marshal', 47: 'Supreme Marshal*', 48: 'Supreme Marshal**', 49: 'Supreme Marshal***',
+    50: 'National Force', 51: 'National Force*', 52: 'National Force**', 53: 'National Force***', 54: 'World Class Force', 55: 'World Class Force*', 56: 'World Class Force**', 57: 'World Class Force***',
+    58: 'Legendary Force', 59: 'Legendary Force*', 60: 'Legendary Force**', 61: 'Legendary Force***', 62: 'God of War', 63: 'God of War*', 64: 'God of War**', 65: 'God of War***',
+    66: 'Titan', 67: 'Titan*', 68: 'Titan**', 69: 'Titan***',
+    70: 'Legends I', 71: 'Legends II', 72: 'Legends III', 73: 'Legends IV', 74: 'Legends V', 75: 'Legends VI', 76: 'Legends VII', 77: 'Legends VIII', 78: 'Legends IX', 79: 'Legends X',
+    80: 'Legends XI', 81: 'Legends XII', 82: 'Legends XIII', 83: 'Legends XIV', 84: 'Legends XV', 85: 'Legends XVI', 86: 'Legends XVII', 87: 'Legends XVIII', 88: 'Legends XIX', 89: 'Legends XX'
 }
 
 GROUND_RANK_POINTS: Dict[int, int] = {
@@ -184,8 +244,10 @@ GROUND_RANK_POINTS: Dict[int, int] = {
     86: 180000000000, 87: 190000000000, 88: 200000000000, 89: 210000000000
 }
 
+GROUND_RANKS: Dict[int, Rank] = {i: Rank(i, GROUND_RANK_NAMES[i], GROUND_RANK_POINTS[i], False) for i in range(1, 90)}
+
 INDUSTRIES = Industries()
 
-TERRAINS: Dict[int, str] = {0: "Standard", 1: 'Industrial', 2: 'Urban', 3: 'Suburbs', 4: 'Airport', 5: 'Plains',
+TERRAINS: Dict[int, str] = {0: 'Standard', 1: 'Industrial', 2: 'Urban', 3: 'Suburbs', 4: 'Airport', 5: 'Plains',
                             6: 'Wasteland', 7: 'Mountains', 8: 'Beach', 9: 'Swamp', 10: 'Mud', 11: 'Hills',
                             12: 'Jungle', 13: 'Forest', 14: 'Desert'}

erepublik/utils.py

@@ -1,35 +1,33 @@
 import datetime
-import inspect
 import os
 import re
 import sys
-import textwrap
 import time
-import traceback
 import unicodedata
 import warnings
+from base64 import b64encode
 from decimal import Decimal
+from logging import Logger
 from pathlib import Path
 from typing import Any, Dict, List, Union
 
+import pytz
 import requests
+from requests import Response
 
-from . import __version__, constants
+from erepublik import __version__, constants
 
 try:
     import simplejson as json
 except ImportError:
     import json
 
-__all__ = ['VERSION', 'calculate_hit', 'caught_error', 'date_from_eday', 'eday_from_date', 'deprecation',
-           'get_air_hit_dmg_value', 'get_file', 'get_ground_hit_dmg_value', 'get_sleep_seconds', 'good_timedelta',
-           'interactive_sleep', 'json', 'localize_dt', 'localize_timestamp', 'normalize_html_json', 'now',
-           'process_error', 'process_warning', 'send_email', 'silent_sleep', 'slugify', 'write_file', 'write_request',
-           'write_interactive_log', 'write_silent_log', 'get_final_hit_dmg', 'wait_for_lock']
-
-if not sys.version_info >= (3, 6):
-    raise AssertionError('This script requires Python version 3.6 and higher\n'
-                         'But Your version is v{}.{}.{}'.format(*sys.version_info))
+__all__ = [
+    'VERSION', 'calculate_hit', 'date_from_eday', 'eday_from_date', 'deprecation', 'get_final_hit_dmg', 'write_file',
+    'get_air_hit_dmg_value', 'get_file', 'get_ground_hit_dmg_value', 'get_sleep_seconds', 'good_timedelta', 'slugify',
+    'interactive_sleep', 'json', 'localize_dt', 'localize_timestamp', 'normalize_html_json', 'now', 'silent_sleep',
+    'json_decode_object_hook', 'json_load', 'json_loads', 'json_dump', 'json_dumps', 'b64json', 'ErepublikJSONEncoder',
+]
 
 VERSION: str = __version__
 
@@ -105,33 +103,11 @@ def interactive_sleep(sleep_seconds: int):
 silent_sleep = time.sleep
 
 
-def _write_log(msg, timestamp: bool = True, should_print: bool = False):
-    erep_time_now = now()
-    txt = f"[{erep_time_now.strftime('%F %T')}] {msg}" if timestamp else msg
-    txt = "\n".join(["\n".join(textwrap.wrap(line, 120)) for line in txt.splitlines()])
-    if not os.path.isdir('log'):
-        os.mkdir('log')
-    with open("log/%s.log" % erep_time_now.strftime('%F'), 'a', encoding="utf-8") as f:
-        f.write("%s\n" % txt)
-    if should_print:
-        print(txt)
-
-
-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)
-
-
 def get_file(filepath: str) -> str:
     file = Path(filepath)
     if file.exists():
         if file.is_dir():
-            return str(file / "new_file.txt")
+            return str(file / 'new_file.txt')
         else:
             version = 1
             try:
@@ -158,166 +134,14 @@ def write_file(filename: str, content: str) -> int:
     return ret
 
 
-def write_request(response: requests.Response, is_error: bool = False):
-    from erepublik import Citizen
-
-    # Remove GET args from url name
-    url = response.url
-    last_index = url.index("?") if "?" in url else len(response.url)
-
-    name = slugify(response.url[len(Citizen.url):last_index])
-    html = response.text
-
-    try:
-        json.loads(html)
-        ext = "json"
-    except json.decoder.JSONDecodeError:
-        ext = "html"
-
-    if not is_error:
-        filename = f"debug/requests/{now().strftime('%F_%H-%M-%S')}_{name}.{ext}"
-        write_file(filename, html)
-    else:
-        return {"name": f"{now().strftime('%F_%H-%M-%S')}_{name}.{ext}",
-                "content": html.encode('utf-8'),
-                "mimetype": "application/json" if ext == "json" else "text/html"}
-
-
-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) and player.r:
-        resp = write_request(player.r, is_error=True)
-    else:
-        resp = {"name": "None.html", "mimetype": "text/html",
-                "content": file_content_template.format(body="<br/>".join(content), title="Error"), }
-
-    if promo:
-        resp = {"name": "%s.html" % name, "mimetype": "text/html",
-                "content": file_content_template.format(title="Promo", body="<br/>".join(content))}
-        subject = f"[eBot][{now().strftime('%F %T')}] Promos: {name}"
-
-    elif captcha:
-        resp = {"name": "%s.html" % name, "mimetype": "text/html",
-                "content": file_content_template.format(title="ReCaptcha", body="<br/>".join(content))}
-        subject = f"[eBot][{now().strftime('%F %T')}] RECAPTCHA: {name}"
-    else:
-        subject = f"[eBot][{now().strftime('%F %T')}] Bug trace: {name}"
-
-    body = "".join(traceback.format_stack()) + \
-           "\n\n" + \
-           "\n".join(content)
-    data = dict(send_mail=True, subject=subject, bugtrace=body)
-    if promo:
-        data.update({'promo': True})
-    elif captcha:
-        data.update({'captcha': True})
-    else:
-        data.update({"bug": True})
-
-    files = [('file', (resp.get("name"), resp.get("content"), resp.get("mimetype"))), ]
-    filename = "log/%s.log" % now().strftime('%F')
-    if os.path.isfile(filename):
-        files.append(('file', (filename[4:], open(filename, 'rb'), "text/plain")))
-    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),
-                               "application/json")))
-    if isinstance(player, Citizen):
-        files.append(('file', ("instance.json", player.to_json(indent=True), "application/json")))
-    requests.post('https://pasts.72.lv', data=data, files=files)
-
-
 def normalize_html_json(js: str) -> str:
-    js = re.sub(r' \'(.*?)\'', lambda a: '"%s"' % a.group(1), js)
+    js = re.sub(r' \'(.*?)\'', lambda a: f'"{a.group(1)}"', js)
     js = re.sub(r'(\d\d):(\d\d):(\d\d)', r'\1\2\3', js)
     js = re.sub(r'([{\s,])(\w+)(:)(?!"})', r'\1"\2"\3', js)
     js = re.sub(r',\s*}', '}', js)
     return js
 
 
-def caught_error(e: Exception):
-    process_error(str(e), "Unclassified", sys.exc_info(), interactive=False)
-
-
-def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commit_id: str = None,
-                  interactive: bool = None):
-    """
-    Process error logging and email sending to developer
-    :param interactive: Should print interactively
-    :type interactive: bool
-    :param log_info: String to be written in output
-    :type log_info: str
-    :param name: String Instance name
-    :type name: str
-    :param exc_info: tuple output from sys.exc_info()
-    :type exc_info: tuple
-    :param citizen: Citizen instance
-    :type citizen: Citizen
-    :param commit_id: Caller's code version's commit id
-    :type commit_id: str
-    """
-    type_, value_, traceback_ = exc_info
-    content = [log_info]
-    content += [f"eRepublik version {VERSION}"]
-    if commit_id:
-        content += [f"Commit id {commit_id}"]
-    content += [str(value_), str(type_), ''.join(traceback.format_tb(traceback_))]
-
-    if interactive:
-        write_interactive_log(log_info)
-    elif interactive is not None:
-        write_silent_log(log_info)
-    trace = inspect.trace()
-    if trace:
-        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:
-        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):
-    """
-    Process error logging and email sending to developer
-    :param log_info: String to be written in output
-    :param name: String Instance name
-    :param exc_info: tuple output from sys.exc_info()
-    :param citizen: Citizen instance
-    :param commit_id: Code's version by commit id
-    """
-    type_, value_, traceback_ = exc_info
-    content = [log_info]
-    if commit_id:
-        content += ["Commit id: %s" % commit_id]
-    content += [str(value_), str(type_), ''.join(traceback.format_tb(traceback_))]
-
-    trace = inspect.trace()
-    if trace:
-        local_vars = trace[-1][0].f_locals
-    else:
-        local_vars = dict()
-    send_email(name, content, citizen, local_vars=local_vars)
-
-
 def slugify(value, allow_unicode=False) -> str:
     """
     Function copied from Django2.2.1 django.utils.text.slugify
@@ -348,7 +172,7 @@ def calculate_hit(strength: float, rang: int, tp: bool, elite: bool, ne: bool, b
 
 def get_ground_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_patriot: bool = False,
                              booster: int = 0, weapon_power: int = 200) -> Decimal:
-    r = requests.get(f"https://www.erepublik.com/en/main/citizen-profile-json/{citizen_id}").json()
+    r = requests.get(f'https://www.erepublik.com/en/main/citizen-profile-json/{citizen_id}').json()
     rang = r['military']['militaryData']['ground']['rankNumber']
     strength = r['military']['militaryData']['ground']['strength']
     elite = r['citizenAttributes']['level'] > 100
@@ -360,7 +184,7 @@ def get_ground_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_
 
 def get_air_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_patriot: bool = False, booster: int = 0,
                           weapon_power: int = 0) -> Decimal:
-    r = requests.get(f"https://www.erepublik.com/en/main/citizen-profile-json/{citizen_id}").json()
+    r = requests.get(f'https://www.erepublik.com/en/main/citizen-profile-json/{citizen_id}').json()
     rang = r['military']['militaryData']['aircraft']['rankNumber']
     elite = r['citizenAttributes']['level'] > 100
     return calculate_hit(0, rang, true_patriot, elite, natural_enemy, booster, weapon_power)
@@ -380,32 +204,96 @@ def get_final_hit_dmg(base_dmg: Union[Decimal, float, str], rang: int,
     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()
-            try:
-                ret = function(instance, *args, **kwargs)
-            except Exception as e:
-                instance.concurrency_available.set()
-                raise e
-            instance.concurrency_available.set()
-            return ret
+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
 
-    return wrapper
+    :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)
+
+
+def json_dump(obj, fp, *args, **kwargs):
+    if not kwargs.get('cls'):
+        kwargs.update(cls=ErepublikJSONEncoder)
+    return json.dump(obj, fp, *args, **kwargs)
+
+
+def json_dumps(obj, *args, **kwargs):
+    if not kwargs.get('cls'):
+        kwargs.update(cls=ErepublikJSONEncoder)
+    return json.dumps(obj, *args, **kwargs)
+
+
+def b64json(obj: Union[Dict[str, Union[int, List[str]]], List[str]]):
+    if isinstance(obj, list):
+        return b64encode(json.dumps(obj, separators=(',', ':')).encode('utf-8')).decode('utf-8')
+    elif isinstance(obj, (int, str)):
+        return obj
+    elif isinstance(obj, dict):
+        for k, v in obj.items():
+            obj[k] = b64json(v)
+    else:
+        from .classes import ErepublikException
+        raise ErepublikException(f'Unhandled object type! obj is {type(obj)}')
+    return b64encode(json.dumps(obj, separators=(',', ':')).encode('utf-8')).decode('utf-8')
+
+
+class ErepublikJSONEncoder(json.JSONEncoder):
+    def default(self, o):
+        try:
+            from erepublik.citizen import Citizen
+            if isinstance(o, Decimal):
+                return float(f"{o:.02f}")
+            elif isinstance(o, datetime.datetime):
+                return dict(__type__='datetime', date=o.strftime("%Y-%m-%d"), time=o.strftime("%H:%M:%S"),
+                            tzinfo=str(o.tzinfo) if o.tzinfo else None)
+            elif isinstance(o, datetime.date):
+                return dict(__type__='date', date=o.strftime("%Y-%m-%d"))
+            elif isinstance(o, datetime.timedelta):
+                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=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):
+                return list(o)
+            elif isinstance(o, Citizen):
+                return o.to_json()
+            elif isinstance(o, Logger):
+                return str(o)
+            elif hasattr(o, '__dict__'):
+                return o.__dict__
+            else:
+                return super().default(o)
+        except Exception as e:  # noqa
+            return str(e)

examples/eat_work_train.py

@@ -26,9 +26,7 @@ def main():
     player.login()
     now = player.now.replace(second=0, microsecond=0)
     dt_max = constants.max_datetime
-    tasks = {
-        'eat': now,
-    }
+    tasks = {}
     if player.config.work:
         tasks.update({'work': now})
     if player.config.train:
@@ -61,7 +59,6 @@ def main():
             if tasks.get('wam', dt_max) <= now:
                 player.write_log("Doing task: Work as manager")
                 success = player.work_as_manager()
-                player.eat()
                 if success:
                     next_time = utils.good_timedelta(now.replace(hour=14, minute=0, second=0, microsecond=0),
                                                      timedelta(days=1))
@@ -70,19 +67,8 @@ def main():
 
                 tasks.update({'wam': next_time})
 
-            if tasks.get('eat', dt_max) <= now:
-                player.write_log("Doing task: eat")
-                player.eat()
-
-                if player.energy.food_fights > player.energy.limit // 10:
-                    next_minutes = 12
-                else:
-                    next_minutes = (player.energy.limit - 5 * player.energy.interval) // player.energy.interval * 6
-
-                next_time = player.energy.reference_time + timedelta(minutes=next_minutes)
-                tasks.update({'eat': next_time})
-
             if tasks.get('ot', dt_max) <= now:
+                player.update_job_info()
                 player.write_log("Doing task: work overtime")
                 if now > player.my_companies.next_ot_time:
                     player.work_ot()

requirements_dev.txt

@@ -1,18 +1,21 @@
 bump2version==1.0.1
-coverage==5.3.1
-edx-sphinx-theme==1.6.0
-flake8==3.8.4
-ipython>=7.19.0
-isort==5.7.0
-pip==20.3.3
-PyInstaller==4.1
-pytz>=2020.0
-pytest==6.2.1
-responses==0.12.1
-setuptools==51.1.1
-Sphinx==3.4.2
-requests>=2.24.0,<2.26.0
+coverage==5.5
+edx-sphinx-theme==3.0.0
+flake8==3.9.2
+ipython>=7.25.0
+jedi!=0.18.0
+isort==5.9.2
+pip==21.1.3
+pre-commit==2.13.0
+pur==5.4.2
+PyInstaller==4.3
 PySocks==1.7.1
-twine==3.3.0
+pytest==6.2.4
+pytz==2021.1
+requests==2.25.1
+requests-toolbelt==0.9.1
+responses==0.13.3
+setuptools==57.1.0
+Sphinx==4.0.3
+twine==3.4.1
 wheel==0.36.2
-pur==5.3.0

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.23.4.1
+current_version = 0.25.1.1
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)\.?(?P<dev>\d+)?
@@ -19,15 +19,15 @@ universal = 1
 
 [flake8]
 exclude = docs,.git,log,debug,venv
-max-line-length = 120
+max-line-length = 240
 ignore = D100,D101,D102,D103
 
 [pycodestyle]
-max-line-length = 120
+max-line-length = 240
 exclude = .git,log,debug,venv, build
 
 [mypy]
-python_version = 3.7
+python_version = 3.8
 check_untyped_defs = True
 ignore_missing_imports = False
 warn_unused_ignores = True
@@ -36,5 +36,4 @@ warn_unused_configs = True
 
 [isort]
 multi_line_output = 2
-line_length = 120
-not_skip = __init__.py
+line_length = 240

setup.py

@@ -12,16 +12,17 @@ with open('HISTORY.rst') as history_file:
     history = history_file.read()
 
 requirements = [
-    'pytz>=2020.0',
-    'requests>=2.24.0,<2.26.0',
-    'PySocks==1.7.1'
+    'PySocks>=1.7.1',
+    'pytz>=2021.1',
+    'requests>=2.25.0',
+    'requests-toolbelt>=0.9.0',
 ]
 
 setup_requirements = []
 
 test_requirements = [
-    "pytest==6.1.2",
-    "responses==0.12.1"
+    "pytest==6.2.4",
+    "responses==0.13.3"
 ]
 
 setup(
@@ -33,8 +34,8 @@ setup(
         'License :: OSI Approved :: MIT License',
         'Natural Language :: English',
         'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.7',
         'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
     ],
     description="Python package for automated eRepublik playing",
     entry_points={},
@@ -45,11 +46,11 @@ setup(
     keywords='erepublik',
     name='eRepublik',
     packages=find_packages(include=['erepublik']),
-    python_requires='>=3.7, <4',
+    python_requires='>=3.8, <4',
     setup_requires=setup_requirements,
     test_suite='tests',
     tests_require=test_requirements,
     url='https://github.com/eeriks/erepublik/',
-    version='0.23.4.1',
+    version='0.25.1.1',
     zip_safe=False,
 )