Bump version: 0.24.0.5 → 0.24.1

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

erepublik/__init__.py

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

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.utcfromtimestamp(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/access_points.py

@@ -1,7 +1,9 @@
 import datetime
+import hashlib
 import random
 import time
 from typing import Any, Dict, List, Mapping, Union
+from requests_toolbelt.utils import dump
 
 from requests import Response, Session
 
@@ -45,6 +47,7 @@ class SlowRequests(Session):
         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': user_agent})
+        self.hooks["response"] = [self._log_response]
 
     @property
     def as_dict(self):
@@ -55,7 +58,7 @@ class SlowRequests(Session):
         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):
@@ -84,30 +87,33 @@ class SlowRequests(Session):
             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:
+            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.request.url, hist_resp, redirect=True)
+                    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_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'))
 
 
 class CitizenBaseAPI:
@@ -141,6 +147,42 @@ class CitizenBaseAPI:
         url = f'http://{username}:{password}@{host}:{port}' if username and password else f'socks5://{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:
+        env = dict(l=['tets', ], s=[], c=["l_chathwe", "l_chatroom"], 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:
+        if not self._req.cookies.get('l_chathwe'):
+            self._req.cookies.set('l_chathwe', 1, expires=int(time.time())+300, path="/en/military", domain='.www.erepublik.com', secure=True)
+        if self._req.cookies.get('sh'):
+            self._req.cookies.pop('sh')
+        if self._req.cookies.get('ch'):
+            self._req.cookies.pop('ch')
+        c = [cookie.name for cookie in self._req.cookies if cookie.domain == '.www.erepublik.com' and not cookie.name.startswith('erpk')]
+        env = dict(l=['tets'], s=[], c=c + ['l_chathwe'], 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)
+        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'})
+
 
 class ErepublikAnniversaryAPI(CitizenBaseAPI):
     def _post_main_collect_anniversary_reward(self) -> Response:
@@ -418,8 +460,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:
@@ -470,24 +514,9 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
                     weaponQuality=weapon, totalEnergy=energy, **kwargs)
         return self.post(f"{self.url}/military/fightDeploy-startDeploy", data=data)
 
-    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) -> Response:
-        env = dict(l=['tets', ], s=[], c=["l_chathwe", "l_chatroom"], m=0)
-        data = dict(_token=self.token, captchaId=captcha_id, env=utils.b64json(env))
-        return self.post(f'{self.url}/main/sessionGetChallenge', data=data)
-
-    def _post_main_session_unlock(
-        self, captcha: int, image: str, challenge: str, coords: List[Dict[str, int]], src: str
-    ) -> Response:
-        env = dict(l=['tets', ], s=[], c=["l_chathwe", "l_chatroom"], m=0)
-        data = dict(_token=self.token, captchaId=captcha, imageId=image, challengeId=challenge,
-                    clickMatrix=utils.json.dumps(coords), isMobile=0, env=utils.b64json(env), src=src)
-        return self.post(f'{self.url}/main/sessionUnlock', 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):

erepublik/citizen.py

@@ -1,5 +1,5 @@
+import logging
 import re
-import sys
 import warnings
 import weakref
 from datetime import datetime, time, timedelta
@@ -9,10 +9,11 @@ from threading import Event
 from time import sleep
 from typing import Any, Dict, List, NoReturn, Optional, Set, Tuple, Union
 
-from requests import HTTPError, RequestException, Response
+from requests import RequestException, Response, HTTPError
 
-from . import access_points, classes, constants, types, utils
+from . import access_points, classes, constants, _types as types, utils
 from .classes import OfferItem
+from ._logging import ErepublikErrorHTTTPHandler, ErepublikFileHandler, ErepublikFormatter, ErepublikLogConsoleHandler
 
 
 class BaseCitizen(access_points.CitizenAPI):
@@ -44,6 +45,8 @@ class BaseCitizen(access_points.CitizenAPI):
     stop_threads: Event = None
     telegram: classes.TelegramReporter = None
 
+    logger: logging.Logger
+
     r: Response = None
     name: str = 'Not logged in!'
     logged_in: bool = False
@@ -58,6 +61,9 @@ class BaseCitizen(access_points.CitizenAPI):
         self.my_companies = classes.MyCompanies(self)
         self.reporter = classes.Reporter(self)
         self.stop_threads = Event()
+        logger_class = logging.getLoggerClass()
+        self.logger = logger_class('Citizen')
+
         self.telegram = classes.TelegramReporter(stop_event=self.stop_threads)
 
         self.config.email = email
@@ -87,6 +93,7 @@ class BaseCitizen(access_points.CitizenAPI):
             self.token = re_login_token.group(1)
             self._login()
         else:
+            self.report_error("Something went wrong! Can't find token in page!")
             raise classes.ErepublikException("Something went wrong! Can't find token in page! Exiting!")
         try:
             self.update_citizen_info(resp.text)
@@ -99,13 +106,13 @@ class BaseCitizen(access_points.CitizenAPI):
             if 'params' in kwargs:
                 if '_token' in kwargs['params']:
                     kwargs['params']['_token'] = self.token
-        if url == self.r.url and not url == self.url:  # Don't duplicate requests, except for homepage
+        if self.r and url == self.r.url and not url == self.url:  # Don't duplicate requests, except for homepage
             response = self.r
         else:
             try:
                 response = super().get(url, **kwargs)
-            except RequestException as e:
-                self.write_log('Network error while issuing GET request', e)
+            except RequestException:
+                self.report_error('Network error while issuing GET request')
                 self.sleep(60)
                 return self.get(url, **kwargs)
 
@@ -137,15 +144,15 @@ class BaseCitizen(access_points.CitizenAPI):
 
         try:
             response = super().post(url, data=data, json=json, **kwargs)
-        except RequestException as e:
-            self.write_log('Network error while issuing POST request', e)
+        except RequestException:
+            self.report_error('Network error while issuing POST request')
             self.sleep(60)
             return self.post(url, data=data, json=json, **kwargs)
 
         try:
             r_json = response.json()
             if (r_json.get('error') or not r_json.get('status')) and r_json.get('message', '') == 'captcha':
-                utils.send_email(self.name, [response.text, ], player=self, captcha=True)
+                self.write_warning('Regular captcha must be filled!', extra=r_json)
         except (AttributeError, utils.json.JSONDecodeError, ValueError, KeyError):
             pass
 
@@ -187,7 +194,6 @@ class BaseCitizen(access_points.CitizenAPI):
             for kind, time_until in self.promos.items():
                 active_promos.append(f"{kind} active until {time_until}")
                 self.reporter.report_promo(kind, time_until)
-            utils.send_email(self.name, active_promos, player=self, promo=True)
 
         new_date = re.search(r"var new_date = '(\d*)';", html)
         if new_date:
@@ -242,6 +248,39 @@ class BaseCitizen(access_points.CitizenAPI):
         """
         self._update_inventory_data(self._get_economy_inventory_items().json())
 
+    def do_captcha_challenge(self, retry: int = 0) -> bool:
+        r = self._get_main_session_captcha()
+        data = re.search(r'\$j\.extend\(SERVER_DATA,([^)]+)\)', r.text)
+        if data:
+            data = utils.json_loads(utils.normalize_html_json(data.group(1)))
+            captcha_id = data.get('sessionValidation', {}).get("captchaId")
+            captcha_data = self._post_main_session_get_challenge(captcha_id).json()
+            coordinates = self.solve_captcha(captcha_data['src'])
+            while True:
+                r = self._post_main_session_unlock(
+                    captcha_id, captcha_data['imageId'], captcha_data['challengeId'], coordinates, captcha_data['src']
+                )
+                rj = r.json()
+                if not rj.get('error') and rj.get('verified'):
+                    return True
+                else:
+                    try:
+                        raise classes.ErepublikException('Captcha failed!')
+                    except classes.ErepublikException:
+                        self.report_error('Captcha failed!')
+                    captcha_data = self._post_main_session_get_challenge(captcha_id, captcha_data['imageId']).json()
+                    coordinates = self.solve_captcha(captcha_data['src'])
+                    if retry < 1:
+                        return False
+                    retry -= 1
+        return False
+
+    def refresh_captcha_image(self, captcha_id: int, image_id: str):
+        return self._post_main_session_get_challenge(captcha_id, image_id).json()
+
+    def solve_captcha(self, src: str) -> List[Dict[str, int]]:
+        raise NotImplemented
+
     @property
     def inventory(self) -> classes.Inventory:
         return self.get_inventory()
@@ -443,17 +482,20 @@ class BaseCitizen(access_points.CitizenAPI):
         self._inventory.offers = offers
         self.food['total'] = sum([self.food[q] * constants.FOOD_ENERGY[q] for q in constants.FOOD_ENERGY])
 
-    def write_log(self, *args, **kwargs):
-        if self.config.interactive:
-            utils.write_interactive_log(*args, **kwargs)
-        else:
-            utils.write_silent_log(*args, **kwargs)
+    def write_log(self, msg: str):
+        self.logger.info(msg)
 
-    def report_error(self, msg: str = "", is_warning: bool = False):
-        if is_warning:
-            utils.process_warning(msg, self.name, sys.exc_info(), self)
-        else:
-            utils.process_error(msg, self.name, sys.exc_info(), self, None, None)
+    def write_warning(self, msg: str = "", extra: Dict[str, Any] = None):
+        if extra is None:
+            extra = {}
+        extra.update(erep_version=utils.VERSION)
+        self.logger.warning(msg, extra=extra)
+
+    def report_error(self, msg: str = "", extra: Dict[str, Any] = None):
+        if extra is None:
+            extra = {}
+        extra.update(erep_version=utils.VERSION)
+        self.logger.error(msg, exc_info=True, stack_info=True, extra=extra)
 
     def sleep(self, seconds: Union[int, float, Decimal]):
         if seconds < 0:
@@ -463,12 +505,43 @@ class BaseCitizen(access_points.CitizenAPI):
         else:
             sleep(seconds)
 
-    def set_debug(self, debug: bool):
-        self.debug = bool(debug)
-        self._req.debug = bool(debug)
+    def init_logger(self):
+        for handler in list(self.logger.handlers):
+            self.logger.removeHandler(handler)
+        formatter = ErepublikFormatter()
+        if self.config.interactive:
+            console_handler = ErepublikLogConsoleHandler()
+            console_handler.setFormatter(formatter)
+            self.logger.addHandler(console_handler)
+        file_handler = ErepublikFileHandler()
+        file_handler.setFormatter(formatter)
+        self.logger.addHandler(file_handler)
+        error_handler = ErepublikErrorHTTTPHandler(self.reporter)
+        error_handler.setFormatter(formatter)
+        self.logger.addHandler(error_handler)
+        self.logger.setLevel(logging.INFO)
+
+    def set_debug(self, enable: bool):
+        self.debug = bool(enable)
+        self._req.debug = bool(enable)
+        self.logger.setLevel(logging.DEBUG if enable else logging.INFO)
+
+        for handler in self.logger.handlers:
+            if isinstance(handler, (ErepublikLogConsoleHandler, ErepublikFileHandler)):
+                handler.setLevel(logging.DEBUG if enable else logging.INFO)
+        self.logger.debug(f"Debug messages {'enabled' if enable else 'disabled'}!")
+
+    def set_interactive(self, enable: bool):
+        for handler in self.logger.handlers:
+            if isinstance(handler, (ErepublikLogConsoleHandler,)):
+                self.logger.removeHandler(handler)
+        if enable:
+            handler = ErepublikLogConsoleHandler()
+            handler.setLevel(logging.DEBUG if self.debug else logging.INFO)
+            self.logger.addHandler(handler)
 
     def to_json(self, indent: bool = False) -> str:
-        return utils.json.dumps(self, cls=classes.ErepublikJSONEncoder, indent=4 if indent else None, sort_keys=True)
+        return utils.json_dumps(self, indent=4 if indent else None, sort_keys=True)
 
     def get_countries_with_regions(self) -> Set[constants.Country]:
         r_json = self._post_main_travel_data().json()
@@ -480,21 +553,29 @@ class BaseCitizen(access_points.CitizenAPI):
 
     def dump_instance(self):
         filename = f"{self.__class__.__name__}__dump.json"
+        cookie_attrs = [
+            "version", "name", "value", "port", "domain", "path", "secure",
+            "expires", "discard", "comment", "comment_url", "rfc2109"
+        ]
+        cookies = [{attr: getattr(cookie, attr) for attr in cookie_attrs} for cookie in self._req.cookies]
+
         with open(filename, 'w') as f:
-            utils.json.dump(dict(config=self.config, cookies=self._req.cookies.get_dict(),
-                                 user_agent=self._req.headers.get("User-Agent")), f, cls=classes.ErepublikJSONEncoder)
-        self.write_log(f"Session saved to: '{filename}'")
+            utils.json_dump(dict(config=self.config, cookies=cookies,
+                                 user_agent=self._req.headers.get("User-Agent")), f)
+        self.logger.debug(f"Session saved to: '{filename}'")
 
     @classmethod
     def load_from_dump(cls, dump_name: str):
         with open(dump_name) as f:
             data = utils.json.load(f, object_hook=utils.json_decode_object_hook)
         player = cls(data['config']['email'], "")
-        player._req.cookies.update(data['cookies'])
+        for cookie in data['cookies']:
+            player._req.cookies.set(**cookie)
         player._req.headers.update({"User-Agent": data['user_agent']})
         for k, v in data.get('config', {}).items():
             if hasattr(player.config, k):
                 setattr(player.config, k, v)
+        player.init_logger()
         player._resume_session()
         return player
 
@@ -508,7 +589,7 @@ class BaseCitizen(access_points.CitizenAPI):
             self.write_log(f"Resumed as: {self.name}")
             if re.search('<div id="accountSecurity" class="it-hurts-when-ip">', resp.text):
                 self.restricted_ip = True
-                # self.report_error("eRepublik has blacklisted IP. Limited functionality!", True)
+                self.write_warning("eRepublik has blacklisted IP. Limited functionality!")
 
             self.logged_in = True
             self.get_csrf_token()
@@ -714,8 +795,7 @@ class BaseCitizen(access_points.CitizenAPI):
         self.r = r
 
         if r.url == f"{self.url}/login":
-            self.write_log("Citizen email and/or password is incorrect!")
-            raise KeyboardInterrupt
+            self.report_error("Citizen email and/or password is incorrect!")
         else:
             re_name_id = re.search(r'<a data-fblog="profile_avatar" href="/en/citizen/profile/(\d+)" '
                                    r'class="user_avatar" title="(.*?)">', r.text)
@@ -726,7 +806,7 @@ class BaseCitizen(access_points.CitizenAPI):
             self.get_csrf_token()
             if re.search('<div id="accountSecurity" class="it-hurts-when-ip">', self.r.text):
                 self.restricted_ip = True
-                # self.report_error('eRepublik has blacklisted IP. Limited functionality!', True)
+                self.write_warning('eRepublik has blacklisted IP. Limited functionality!', )
 
             self.logged_in = True
 
@@ -734,30 +814,33 @@ class BaseCitizen(access_points.CitizenAPI):
         try:
             j = response.json()
             if j['error'] and j['message'] == 'Too many requests':
-                self.write_log('Made too many requests! Sleeping for 30 seconds.')
+                self.write_warning('Made too many requests! Sleeping for 30 seconds.')
                 self.sleep(30)
         except (utils.json.JSONDecodeError, KeyError, TypeError):
             pass
         if response.status_code >= 400:
             self.r = response
-            if response.status_code >= 500:
+            if response.text == 'Please verify your account.' or response.text == 'Forbidden':
+                self.do_captcha_challenge()
+                return True
+            elif response.status_code >= 500:
                 if self.restricted_ip:
                     self._req.cookies.clear()
                     return True
-                self.write_log('eRepublik servers are having internal troubles. Sleeping for 5 minutes')
-                self.sleep(5 * 60)
+                self.write_warning('eRepublik servers are having internal troubles. Sleeping for 1 minutes')
+                self.sleep(1 * 60)
             else:
                 raise classes.ErepublikException(f"HTTP {response.status_code} error!")
 
         if re.search(r'Occasionally there are a couple of things which we need to check or to implement in order make '
                      r'your experience in eRepublik more pleasant. <strong>Don\'t worry about ongoing battles, timer '
                      r'will be stopped during maintenance.</strong>', response.text):
-            self.write_log('eRepublik is having maintenance. Sleeping for 5 minutes')
+            self.write_warning('eRepublik is having maintenance. Sleeping for 5 mi#nutes')
             self.sleep(5 * 60)
             return True
 
-        if re.search('We are experiencing some tehnical dificulties', response.text):
-            self.write_log('eRepublik is having technical difficulties. Sleeping for 5 minutes')
+        elif re.search('We are experiencing some tehnical dificulties', response.text):
+            self.write_warning('eRepublik is having technical difficulties. Sleeping for 5 minutes')
             self.sleep(5 * 60)
             return True
 
@@ -775,8 +858,11 @@ class BaseCitizen(access_points.CitizenAPI):
         :param msg: Message about the action
         :param kwargs: Extra information regarding action
         """
-        kwargs = utils.json.loads(utils.json.dumps(kwargs or {}, cls=classes.ErepublikJSONEncoder))
+        kwargs = utils.json_loads(utils.json_dumps(kwargs or {}))
         action = action[:32]
+        if msg.startswith('Unable to'):
+            self.write_warning(msg)
+        else:
             self.write_log(msg)
         if self.reporter.allowed:
             self.reporter.report_action(action, kwargs, msg)
@@ -803,7 +889,7 @@ class CitizenAnniversary(BaseCitizen):
 
     def spin_wheel_of_fortune(self, max_cost=0, spin_count=0):
         if not self.config.spin_wheel_of_fortune:
-            self.write_log("Unable to spin wheel of fortune because 'config.spin_wheel_of_fortune' is False")
+            self.write_warning("Unable to spin wheel of fortune because 'config.spin_wheel_of_fortune' is False")
             return
 
         def _write_spin_data(cost: int, prize: str):
@@ -1009,7 +1095,7 @@ class CitizenCompanies(BaseCitizen):
         if wam_list:
             data.update(extra)
             if not self.details.current_region == wam_holding.region:
-                self.write_log("Unable to work as manager because of location - please travel!")
+                self.write_warning("Unable to work as manager because of location - please travel!")
                 return
 
             employ_factories = self.my_companies.get_employable_factories()
@@ -1035,7 +1121,7 @@ class CitizenCompanies(BaseCitizen):
         """
         Assigns factory to new holding
         """
-        self.write_log(f"{company} moved to {holding}")
+        self.logger.debug(f"{company} moved to {holding}")
         company._holding = weakref.ref(holding)
         return self._post_economy_assign_to_holding(company.id, holding.id)
 
@@ -1050,7 +1136,7 @@ class CitizenCompanies(BaseCitizen):
         company_name = constants.INDUSTRIES[industry_id]
         if building_type == 2:
             company_name = 'Storage'
-        self.write_log(f'{company_name} created!')
+        self.logger.info(f'{company_name} created!')
         return self._post_economy_create_company(industry_id, building_type)
 
 
@@ -1102,8 +1188,7 @@ class CitizenEconomy(CitizenTravel):
             if buy is None:
                 pass
             elif buy['error']:
-                msg = f'Unable to buy q{q} house! \n{buy["message"]}'
-                self.write_log(msg)
+                self.write_warning(f'Unable to buy q{q} house! {buy["message"]}')
             else:
                 ok_to_activate = True
         else:
@@ -1209,7 +1294,7 @@ class CitizenEconomy(CitizenTravel):
         if isinstance(industry, str):
             industry = constants.INDUSTRIES[industry]
         if not constants.INDUSTRIES[industry]:
-            self.write_log(f"Trying to sell unsupported industry {industry}")
+            self.write_warning(f"Trying to sell unsupported industry {industry}")
 
         _inv_qlt = quality if industry in [1, 2, 3, 4, 23] else 0
         final_kind = industry in [1, 2, 4, 23]
@@ -1264,7 +1349,7 @@ class CitizenEconomy(CitizenTravel):
             quality = 1
             product_name = raw_short_names[product_name]
         elif not constants.INDUSTRIES[product_name]:
-            self.write_log(f"Industry '{product_name}' not implemented")
+            self.report_error(f"Industry '{product_name}' not implemented")
             raise classes.ErepublikException(f"Industry '{product_name}' not implemented")
 
         offers: Dict[str, classes.OfferItem] = {}
@@ -1297,7 +1382,7 @@ class CitizenEconomy(CitizenTravel):
                             constants.COUNTRIES[int(offer['country_id'])], int(offer['amount']),
                             int(offer['id']), int(offer['citizen_id'])
                         )
-        self.write_log(f"Scraped market in {self.now - start_dt}!")
+        self.logger.debug(f"Scraped market in {self.now - start_dt}!")
 
         return offers
 
@@ -1321,7 +1406,7 @@ class CitizenEconomy(CitizenTravel):
             self.update_inventory()
         else:
             s = f"Don't have enough money! Needed: {amount * cheapest.price}cc, Have: {self.details.cc}cc"
-            self.write_log(s)
+            self.write_warning(s)
             self._report_action('BUY_FOOD', s)
 
     def get_monetary_offers(self, currency: int = 62) -> List[Dict[str, Union[int, float]]]:
@@ -1385,7 +1470,7 @@ class CitizenEconomy(CitizenTravel):
             self._report_action('DONATE_ITEMS', msg)
             return amount
         elif re.search('You must wait 5 seconds before donating again', response.text):
-            self.write_log('Previous donation failed! Must wait at least 5 seconds before next donation!')
+            self.write_warning('Previous donation failed! Must wait at least 5 seconds before next donation!')
             self.sleep(5)
             return self.donate_items(citizen_id, int(amount), industry_id, quality)
         else:
@@ -1537,7 +1622,7 @@ class CitizenMedia(BaseCitizen):
                                 kwargs=article_data)
             self._get_main_delete_article(article_id)
         else:
-            self.write_log(f"Unable to delete article (#{article_id})!")
+            self.write_warning(f"Unable to delete article (#{article_id})!")
 
 
 class CitizenMilitary(CitizenTravel):
@@ -1770,7 +1855,7 @@ class CitizenMilitary(CitizenTravel):
                 side = battle.defender if defender_side else battle.invader
 
             if not silent:
-                self.write_log(battle)
+                self.write_log(str(battle))
 
             travel = (self.config.travel_to_fight and self.should_travel_to_fight() or self.config.force_travel) \
                 if travel_needed else True
@@ -1793,17 +1878,7 @@ class CitizenMilitary(CitizenTravel):
                 if battle.start > self.now:
                     self.sleep(utils.get_sleep_seconds(battle.start))
 
-                if travel_needed:
-                    if battle.is_rw:
-                        countries_to_travel = [battle.defender.country]
-                    elif self.details.current_country in battle.invader.allies:
-                        countries_to_travel = battle.invader.deployed + [battle.invader.country]
-                        side = battle.invader
-                    else:
-                        countries_to_travel = battle.defender.deployed + [battle.defender.country]
-                        side = battle.defender
-
-                    if not self.travel_to_battle(battle, countries_to_travel):
+                if travel_needed and not self.change_division(battle, division, side):
                     break
 
                 if self.change_division(battle, division):
@@ -1832,6 +1907,7 @@ class CitizenMilitary(CitizenTravel):
         :rtype: int
         """
         if self.restricted_ip:
+            self.write_warning('Fighting is not allowed from restricted IP!')
             self._report_action('IP_BLACKLISTED', 'Fighting is not allowed from restricted IP!')
             return 1
         if not division.is_air and self.config.boosters:
@@ -1839,15 +1915,14 @@ class CitizenMilitary(CitizenTravel):
         if side is None:
             side = battle.defender if self.details.citizenship in battle.defender.allies + [
                 battle.defender.country] else battle.invader
-        error_count = 0
-        ok_to_fight = True
         if count is None:
             count = self.should_fight()[0]
 
-        self.write_log(f"Fighting in battle for {battle.region_name} on {side} side\n{battle}\n{str(division)}")
+        self.write_log(f"Fighting in battle for {battle.region_name} on {side} side in d{division.div}")
 
-        total_damage = 0
-        total_hits = 0
+        if self.now < utils.localize_dt(datetime(2021, 2, 8)):
+            error_count = total_damage = total_hits = 0
+            ok_to_fight = True
             while ok_to_fight and error_count < 10 and count > 0:
                 while all((count > 0, error_count < 10, self.energy.recovered >= 50)):
                     hits, error, damage = self._shoot(battle, division, side)
@@ -1865,6 +1940,20 @@ class CitizenMilitary(CitizenTravel):
                         if total_damage:
                             self.report_fighting(battle, not side.is_defender, division, total_damage, total_hits)
             return error_count
+        else:
+            deployment_id = self.deploy(division, side, count * 10)
+            self.sleep(count // 3)  # TODO: connect to eRepublik's WS and get from there when deploy ends
+            energy_used = 0
+            if deployment_id:
+                self.write_warning('If erepublik responds with HTTP 500 Internal Error, it is kind of ok, because deployment has not finished yet.')
+                deployment_data = self._post_military_fight_deploy_deploy_report_data(deployment_id).json()
+                if not deployment_data.get('error'):
+                    data = deployment_data['data']
+                    total_damage = int(data['damage'].replace(',', ''))
+                    energy_used = int(data['energySpent'].replace(',', ''))
+                    self.details.pp += int(data['rewards']['prestigePoints'].replace(',', ''))
+                    self.report_fighting(battle, not side.is_defender, division, total_damage, energy_used // 10)
+            return energy_used
 
     def _shoot(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide):
         if division.is_air:
@@ -1888,13 +1977,13 @@ class CitizenMilitary(CitizenTravel):
             elif r_json.get('message') == 'NOT_ENOUGH_WEAPONS':
                 self.set_default_weapon(battle, division)
             elif r_json.get('message') == "Cannot activate a zone with a non-native division":
-                self.write_log('Wrong division!!')
+                self.write_warning('Wrong division!!')
                 return 0, 10, 0
             elif r_json.get('message') == 'ZONE_INACTIVE':
-                self.write_log('Wrong division!!')
+                self.write_warning('Wrong division!!')
                 return 0, 10, 0
             elif r_json.get('message') == 'NON_BELLIGERENT':
-                self.write_log("Dictatorship/Liberation wars are not supported!")
+                self.write_warning("Dictatorship/Liberation wars are not supported!")
                 return 0, 10, 0
             elif r_json.get('message') in ['FIGHT_DISABLED', 'DEPLOYMENT_MODE']:
                 self._post_main_profile_update('options',
@@ -1981,18 +2070,20 @@ class CitizenMilitary(CitizenTravel):
         self._report_action('MILITARY_BOMB', f"Deployed {deployed_count} bombs in battle {battle.id}")
         return deployed_count
 
-    def change_division(self, battle: classes.Battle, division: classes.BattleDivision) -> bool:
+    def change_division(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide = None) -> bool:
         """Change division.
 
-        :param battle: Battle
-        :type battle: Battle
+        :param battle: classes.Battle
+        :type battle: classes.Battle
         :param division: int target division to switch to
-        :type division: BattleDivision
+        :type division: classes.BattleDivision
+        :param side: Side to choose
+        :type side: classes.BattleSide
         :return:
         """
-        resp = self._post_main_battlefield_change_division(battle.id, division.id)
+        resp = self._post_main_battlefield_change_division(battle.id, division.id, side.id if side else None)
         if resp.json().get('error'):
-            self.write_log(resp.json().get('message'))
+            self.write_warning(resp.json().get('message'))
             return False
         self._report_action('MILITARY_DIV_SWITCH', f"Switched to d{division.div} in battle {battle.id}",
                             kwargs=resp.json())
@@ -2102,7 +2193,7 @@ class CitizenMilitary(CitizenTravel):
                 count = (self.energy.limit * 3) // 10
                 force_fight = True
             else:
-                self.write_log('Waiting for fully recovered energy before leveling up.', False)
+                self.write_log('Waiting for fully recovered energy before leveling up.')
 
         # Levelup reachable
         elif self.is_levelup_close:
@@ -2233,38 +2324,22 @@ class CitizenMilitary(CitizenTravel):
         if self.config.telegram:
             self.telegram.report_fight(battle, invader, division, damage, hits)
 
-    def do_captcha_challenge(self) -> bool:
-        r = self._get_main_session_captcha()
-        data = re.search(r'\$j\.extend\(SERVER_DATA,([^)]+)\)', r.text)
-        if data:
-            data = utils.json_loads(utils.normalize_html_json(data.group(1)))
-            captcha_id = data.get('sessionValidation', {}).get("captchaId")
-            captcha_data = self._post_main_session_get_challenge(captcha_id).json()
-            coordinates = self.solve_captcha(captcha_data.get('src'))
-            r = self._post_main_session_unlock(
-                captcha_id, captcha_data['imageId'], captcha_data['challengeId'], coordinates, captcha_data['src']
-            ).json()
-            if not r.get('error') and r.get('verified'):
-                return True
-            else:
-                self.report_error('Captcha failed!')
-                return self.do_captcha_challenge()
-        return False
-
-    def solve_captcha(self, src: str) -> List[Dict[str, int]]:
-        raise NotImplemented
-
     def get_deploy_inventory(self, division: classes.BattleDivision, side: classes.BattleSide):
         ret = self._post_fight_deploy_get_inventory(division.battle.id, side.id, division.id).json()
         # if ret.get('recoverableEnergyBuyFood'):
         #     self.buy_food()
         #     return self.get_deploy_inventory(division, side)
         if ret.get('captcha'):
-            while not self.do_captcha_challenge():
-                self.sleep(5)
+            self.do_captcha_challenge()
+        if ret.get('error'):
+            if ret.get('message') == 'Deployment disabled.':
+                self._post_main_profile_update('options', params='{"optionName":"enable_web_deploy","optionValue":"on"}')
+                return self.get_deploy_inventory(division, side)
+            else:
+                self.report_error(f"Unable to get deployment inventory because: {ret.get('message')}")
         return ret
 
-    def deploy(self, division: classes.BattleDivision, side: classes.BattleSide, energy: int):
+    def deploy(self, division: classes.BattleDivision, side: classes.BattleSide, energy: int, _retry=0) -> int:
         _energy = int(energy)
         deploy_inv = self.get_deploy_inventory(division, side)
         if not deploy_inv['minEnergy'] <= energy <= deploy_inv['maxEnergy']:
@@ -2276,8 +2351,8 @@ class CitizenMilitary(CitizenTravel):
             if source['type'] == 'pool':
                 _energy -= source['energy']
             elif source['type'] in ['food', 'energy_bar']:
-                recovers = source['energy'] / source['amount']
-                amount = recoverable // recovers
+                recovers = source['energy'] // source['amount']
+                amount = (recoverable if source['type'] == 'food' else _energy) // recovers
                 amount = amount if amount < source['amount'] else source['amount']
                 if amount > 0:
                     energy_sources.update({f'energySources[{source_idx}][quality]': source['quality']})
@@ -2286,20 +2361,29 @@ class CitizenMilitary(CitizenTravel):
                     used_energy = amount * recovers
                     recoverable -= used_energy
                     _energy -= used_energy
+            if _energy <= 0:
+                break
+        if _energy > 0:
             energy -= _energy
         weapon_q = -1
         weapon_strength = 0
         if not division.is_air:
             for weapon in sorted(deploy_inv['weapons'], key=lambda w: w['damageperHit']):
-                if weapon['damageperHit'] > weapon_strength and weapon['amount'] > 50:
+                if (weapon['damageperHit'] or 0) > weapon_strength and (weapon['amount'] or 0) > 50:
                     weapon_q = weapon['quality']
         r = self._post_fight_deploy_start_deploy(
             division.battle.id, side.id, division.id, energy, weapon_q, **energy_sources
         ).json()
-        self.write_log(r.get('message'))
         if r.get('error'):
-            self.report_error('Deploy failed!')
-        return energy
+            self.report_error(f"Deploy failed: '{r.get('message')}'")
+            if r.get('message') == 'Deployment disabled.':
+                self._post_main_profile_update('options', params='{"optionName":"enable_web_deploy","optionValue":"on"}')
+                if _retry < 5:
+                    return self.deploy(division, side, energy, _retry+1)
+                else:
+                    self.report_error('Unable to deploy 5 times!')
+            return 0
+        return r.get('deploymentId')
 
 
 class CitizenPolitics(BaseCitizen):
@@ -2372,7 +2456,7 @@ class CitizenSocial(BaseCitizen):
     def add_every_player_as_friend(self):
         cities = []
         cities_dict = {}
-        self.write_log('WARNING! This will take a lot of time.')
+        self.write_warning('This will take a lot of time.')
         rj = self._post_main_travel_data(regionId=662, check='getCountryRegions').json()
         for region_data in rj.get('regions', {}).values():
             cities.append(region_data['cityId'])
@@ -2483,7 +2567,7 @@ class CitizenTasks(CitizenEconomy):
             self._eat('blue')
             if self.energy.food_fights < 1:
                 seconds = (self.energy.reference_time - self.now).total_seconds()
-                self.write_log(f"I don't have energy to work. Will sleep for {seconds}s")
+                self.write_warning(f"I don't have energy to work. Will sleep for {seconds}s")
                 self.sleep(seconds)
                 self._eat('blue')
             self.work()
@@ -2513,7 +2597,7 @@ class CitizenTasks(CitizenEconomy):
                 if self.energy.food_fights < len(tgs):
                     large = max(self.energy.reference_time, self.now)
                     sleep_seconds = utils.get_sleep_seconds(large)
-                    self.write_log(f"I don't have energy to train. Will sleep for {sleep_seconds} seconds")
+                    self.write_warning(f"I don't have energy to train. Will sleep for {sleep_seconds} seconds")
                     self.sleep(sleep_seconds)
                     self._eat('blue')
                 self.train()
@@ -2537,7 +2621,7 @@ class CitizenTasks(CitizenEconomy):
             if self.energy.food_fights < 1:
                 large = max(self.energy.reference_time, self.now)
                 sleep_seconds = utils.get_sleep_seconds(large)
-                self.write_log(f"I don't have energy to work OT. Will sleep for {sleep_seconds}s")
+                self.write_warning(f"I don't have energy to work OT. Will sleep for {sleep_seconds}s")
                 self.sleep(sleep_seconds)
                 self._eat('blue')
             self.work_ot()
@@ -2617,7 +2701,7 @@ class _Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
             if hasattr(self.config, key):
                 setattr(self.config, key, value)
             else:
-                self.write_log(f"Unknown config parameter! ({key}={value})")
+                self.write_warning(f"Unknown config parameter! ({key}={value})")
 
     def login(self):
         self.get_csrf_token()
@@ -2630,6 +2714,7 @@ class _Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
                                   self.name)
             self.telegram.send_message(f"*Started* {utils.now():%F %T}")
 
+        self.init_logger()
         self.update_all(True)
 
     def update_citizen_info(self, html: str = None):
@@ -2648,7 +2733,7 @@ class _Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
                 if self.details.gold >= 54:
                     self.buy_tg_contract()
                 else:
-                    self.write_log(f'Training ground contract active but '
+                    self.write_warning('Training ground contract active but '
                                         f"don't have enough gold ({self.details.gold}g {self.details.cc}cc)")
         if self.energy.is_energy_full and self.config.telegram:
             self.telegram.report_full_energy(self.energy.available, self.energy.limit, self.energy.interval)
@@ -2750,7 +2835,7 @@ class _Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
             count = count if max_count > count else max_count
 
         if not silent:
-            self.write_log(log_msg, False)
+            self.write_log(log_msg)
 
         return count, log_msg, force_fight
 
@@ -2806,17 +2891,17 @@ class _Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
             if self.energy.limit - self.energy.recovered > self.energy.interval or not self.energy.recoverable % 2:
                 super().eat()
             else:
-                self.write_log("I don't want to eat right now!")
+                self.logger.debug("I don't want to eat right now!")
         else:
-            self.write_log(f"I'm out of food! But I'll try to buy some!\n{self.food}")
+            self.write_warning(f"I'm out of food! But I'll try to buy some!\n{self.food}")
             self.buy_food()
             if self.food['total'] > self.energy.interval:
                 super().eat()
             else:
-                self.write_log('I failed to buy food')
+                self.write_warning('I failed to buy food')
 
     def eat_eb(self):
-        self.write_log('Eating energy bar')
+        self.write_warning('Eating energy bar')
         if self.energy.recoverable:
             self._eat('blue')
         self._eat('orange')
@@ -2880,7 +2965,7 @@ class _Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
                     if not rj.get('error'):
                         amount_needed -= amount
                     else:
-                        self.write_log(rj.get('message', ""))
+                        self.write_warning(rj.get('message', ""))
                         self._report_action(
                             'ECONOMY_BUY', f"Unable to buy products! Reason: {rj.get('message')}", kwargs=rj
                         )
@@ -2899,11 +2984,11 @@ class _Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
             self._wam(holding)
         elif response.get('message') == 'tax_money':
             self._report_action('WORK_AS_MANAGER', 'Not enough money to work as manager!', kwargs=response)
-            self.write_log('Not enough money to work as manager!')
+            self.write_warning('Not enough money to work as manager!')
         else:
             msg = f'I was not able to wam and or employ because:\n{response}'
             self._report_action('WORK_AS_MANAGER', f'Worked as manager failed: {msg}', kwargs=response)
-            self.write_log(msg)
+            self.write_warning(msg)
 
     def work_as_manager(self) -> bool:
         """ Does Work as Manager in all holdings with wam. If employees assigned - work them also
@@ -2940,12 +3025,12 @@ class _Citizen(CitizenAnniversary, CitizenCompanies, CitizenLeaderBoard,
 
             wam_count = self.my_companies.get_total_wam_count()
             if wam_count:
-                self.write_log(f"Wam ff lockdown is now {wam_count}, was {self.my_companies.ff_lockdown}")
+                self.logger.debug(f"Wam ff lockdown is now {wam_count}, was {self.my_companies.ff_lockdown}")
             self.my_companies.ff_lockdown = wam_count
             self.travel_to_residence()
             return bool(wam_count)
         else:
-            self.write_log('Did not WAM because I would mess up levelup!')
+            self.write_warning('Did not WAM because I would mess up levelup!')
             self.my_companies.ff_lockdown = 0
 
         self.update_companies()
@@ -2987,8 +3072,6 @@ class Citizen(_Citizen):
     def update_weekly_challenge(self):
         if not self._update_lock.wait(self._update_timeout):
             e = f'Update concurrency not freed in {self._update_timeout}sec!'
-            self.write_log(e)
-            if self.debug:
             self.report_error(e)
             return None
         try:
@@ -3000,8 +3083,6 @@ class Citizen(_Citizen):
     def update_companies(self):
         if not self._update_lock.wait(self._update_timeout):
             e = f'Update concurrency not freed in {self._update_timeout}sec!'
-            self.write_log(e)
-            if self.debug:
             self.report_error(e)
             return None
         try:
@@ -3013,8 +3094,6 @@ class Citizen(_Citizen):
     def update_war_info(self):
         if not self._update_lock.wait(self._update_timeout):
             e = f'Update concurrency not freed in {self._update_timeout}sec!'
-            self.write_log(e)
-            if self.debug:
             self.report_error(e)
             return None
         try:
@@ -3026,8 +3105,6 @@ class Citizen(_Citizen):
     def update_job_info(self):
         if not self._update_lock.wait(self._update_timeout):
             e = f'Update concurrency not freed in {self._update_timeout}sec!'
-            self.write_log(e)
-            if self.debug:
             self.report_error(e)
             return None
         try:
@@ -3039,8 +3116,6 @@ class Citizen(_Citizen):
     def update_money(self, page: int = 0, currency: int = 62):
         if not self._update_lock.wait(self._update_timeout):
             e = f'Update concurrency not freed in {self._update_timeout}sec!'
-            self.write_log(e)
-            if self.debug:
             self.report_error(e)
             return None
         try:
@@ -3052,8 +3127,6 @@ class Citizen(_Citizen):
     def update_inventory(self):
         if not self._update_lock.wait(self._update_timeout):
             e = f'Update concurrency not freed in {self._update_timeout}sec!'
-            self.write_log(e)
-            if self.debug:
             self.report_error(e)
             return None
         try:
@@ -3065,8 +3138,6 @@ class Citizen(_Citizen):
     def _work_as_manager(self, wam_holding: classes.Holding) -> Optional[Dict[str, Any]]:
         if not self._concurrency_lock.wait(self._concurrency_timeout):
             e = f'Concurrency not freed in {self._concurrency_timeout}sec!'
-            self.write_log(e)
-            if self.debug:
             self.report_error(e)
             return None
         try:
@@ -3079,8 +3150,6 @@ class Citizen(_Citizen):
               count: int = None, use_ebs: bool = False) -> Optional[int]:
         if not self._concurrency_lock.wait(self._concurrency_timeout):
             e = f'Concurrency not freed in {self._concurrency_timeout}sec!'
-            self.write_log(e)
-            if self.debug:
             self.report_error(e)
             return None
         try:
@@ -3093,8 +3162,6 @@ class Citizen(_Citizen):
                     count: int = 1) -> Optional[int]:
         if not self._concurrency_lock.wait(self._concurrency_timeout):
             e = f'Concurrency not freed in {self._concurrency_timeout}sec!'
-            self.write_log(e)
-            if self.debug:
             self.report_error(e)
             return None
         try:
@@ -3106,8 +3173,6 @@ class Citizen(_Citizen):
     def buy_market_offer(self, offer: OfferItem, amount: int = None) -> Optional[Dict[str, Any]]:
         if not self._concurrency_lock.wait(self._concurrency_timeout):
             e = f'Concurrency not freed in {self._concurrency_timeout}sec!'
-            self.write_log(e)
-            if self.debug:
             self.report_error(e)
             return None
         try:

erepublik/classes.py

@@ -7,11 +7,11 @@ from typing import Any, Dict, Generator, Iterable, List, NamedTuple, NoReturn, U
 
 from requests import Response, Session, post
 
-from . import constants, types, utils
+from . import constants, _types as types, utils
 
 __all__ = ['Battle', 'BattleDivision', 'BattleSide', 'Company', 'Config', 'Details', 'Energy', 'ErepublikException',
-           'ErepublikJSONEncoder', 'ErepublikNetworkException', 'EnergyToFight', 'Holding', 'Inventory', 'MyCompanies',
-           'OfferItem', 'Politics', 'Reporter', 'TelegramReporter', ]
+           'ErepublikNetworkException', 'EnergyToFight', 'Holding', 'Inventory', 'MyCompanies', 'OfferItem', 'Politics',
+           'Reporter', 'TelegramReporter', ]
 
 
 class ErepublikException(Exception):
@@ -482,6 +482,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):
@@ -603,10 +605,10 @@ class Reporter:
         if self.__to_update:
             for unreported_data in self.__to_update:
                 unreported_data.update(player_id=self.citizen_id, key=self.key)
-                unreported_data = utils.json.loads(utils.json.dumps(unreported_data, cls=ErepublikJSONEncoder))
+                unreported_data = utils.json_loads(utils.json_dumps(unreported_data))
                 self._req.post(f"{self.url}/bot/update", json=unreported_data)
             self.__to_update.clear()
-        data = utils.json.loads(utils.json.dumps(data, cls=ErepublikJSONEncoder))
+        data = utils.json.loads(utils.json_dumps(data))
         r = self._req.post(f"{self.url}/bot/update", json=data)
         return r
 
@@ -687,33 +689,6 @@ class Reporter:
             return []
 
 
-class ErepublikJSONEncoder(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=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()
-        try:
-            return super().default(o)
-        except Exception as e:  # noqa
-            return 'Object is not JSON serializable'
-
-
 class BattleSide:
     points: int
     deployed: List[constants.Country]

erepublik/utils.py

@@ -1,10 +1,8 @@
 import datetime
-import inspect
 import os
 import re
 import sys
 import time
-import traceback
 import unicodedata
 import warnings
 from base64 import b64encode
@@ -14,6 +12,7 @@ from typing import Any, Dict, List, Union
 
 import pytz
 import requests
+from requests import Response
 
 from . import __version__, constants
 
@@ -22,12 +21,12 @@ try:
 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',
-           'json_decode_object_hook', 'json_load', 'json_loads']
+__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__
 
@@ -103,25 +102,25 @@ 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
-    if not os.path.isdir('log'):
-        os.mkdir('log')
-    with open(f'log/{erep_time_now.strftime("%F")}.log', 'a', encoding='utf-8') as f:
-        f.write(f'{txt}\n')
-    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 _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
+#     if not os.path.isdir('log'):
+#         os.mkdir('log')
+#     with open(f'log/{erep_time_now.strftime("%F")}.log', 'a', encoding='utf-8') as f:
+#         f.write(f'{txt}\n')
+#     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:
@@ -155,89 +154,6 @@ 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 dict(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 = dict(name='None.html', mimetype='text/html',
-                    content=file_content_template.format(body='<br/>'.join(content), title='Error'))
-
-    if promo:
-        resp = dict(name=f"{name}.html", 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 = dict(name=f'{name}.html', 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 = f'log/{now().strftime("%F")}.log'
-    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 ErepublikJSONEncoder
-        files.append(('file', ('local_vars.json', json.dumps(local_vars, cls=ErepublikJSONEncoder),
-                               "application/json")))
-    if isinstance(player, Citizen):
-        files.append(('file', ('instance.json', player.to_json(indent=True), "application/json")))
-    requests.post('https://pasts.72.lv', data=data, files=files)
-
-
 def normalize_html_json(js: str) -> str:
     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)
@@ -246,72 +162,6 @@ def normalize_html_json(js: str) -> str:
     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 += [f'Commit id: {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
@@ -378,25 +228,25 @@ 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
-
-    return wrapper
+# 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
+#
+#     return wrapper
 
 
 def json_decode_object_hook(
@@ -432,9 +282,21 @@ def json_loads(s: str, **kwargs):
     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).encode('utf-8')).decode('utf-8')
+        return b64encode(json.dumps(obj).replace(' ', '').encode('utf-8')).decode('utf-8')
     elif isinstance(obj, (int, str)):
         return obj
     elif isinstance(obj, dict):
@@ -443,4 +305,31 @@ def b64json(obj: Union[Dict[str, Union[int, List[str]]], List[str]]):
     else:
         from .classes import ErepublikException
         raise ErepublikException(f'Unhandled object type! obj is {type(obj)}')
-    return b64encode(json.dumps(obj).encode('utf-8')).decode('utf-8')
+    return b64encode(json.dumps(obj).replace(' ', '').encode('utf-8')).decode('utf-8')
+
+
+class ErepublikJSONEncoder(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=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()
+        try:
+            return super().default(o)
+        except Exception as e:  # noqa
+            return 'Object is not JSON serializable'

setup.cfg

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

setup.py

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