Bump version: 0.18.2 → 0.18.3

Makefile

@@ -43,6 +43,8 @@ clean-pyc: ## remove Python file artifacts
 	find . -name '*.pyo' -exec rm -f {} +
 	find . -name '*~' -exec rm -f {} +
 	find . -name '__pycache__' -exec rm -fr {} +
+	rm -rf debug/
+	rm -rf log/
 
 clean-test: ## remove test and coverage artifacts
 	rm -fr .tox/

erepublik/__init__.py

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

erepublik/citizen.py

@@ -1,5 +1,6 @@
 import re
 import sys
+import warnings
 from collections import defaultdict
 from datetime import datetime, timedelta
 from itertools import product
@@ -13,6 +14,7 @@ from requests import Response, RequestException
 from erepublik.classes import (CitizenAPI, Battle, Reporter, Config, Energy, Details, Politics, MyCompanies,
                                TelegramBot, ErepublikException, BattleDivision, MyJSONEncoder)
 from erepublik.utils import *
+from erepublik.utils import process_warning
 
 
 class Citizen(CitizenAPI):
@@ -41,15 +43,15 @@ class Citizen(CitizenAPI):
 
     eday = 0
 
-    energy: Energy
+    energy: Energy = None
-    details: Details
+    details: Details = None
-    politics: Politics
+    politics: Politics = None
-    my_companies: MyCompanies
+    my_companies: MyCompanies = None
-    reporter: Reporter
+    reporter: Reporter = None
-    stop_threads: Event
+    stop_threads: Event = None
-    telegram: TelegramBot
+    telegram: TelegramBot = None
 
-    r: Response
+    r: Response = None
     name = "Not logged in!"
     debug = False
     __registered = False
@@ -712,35 +714,35 @@ class Citizen(CitizenAPI):
             # CS Battles
             elif self.details.citizenship in battle_sides:
                 if battle.is_air:
-                    cs_battles_ground.append(battle.id)
-                else:
                     cs_battles_air.append(battle.id)
+                else:
+                    cs_battles_ground.append(battle.id)
 
             # Current location battles:
             elif self.details.current_country in battle_sides:
                 if battle.is_air:
-                    deployed_battles_ground.append(battle.id)
-                else:
                     deployed_battles_air.append(battle.id)
+                else:
+                    deployed_battles_ground.append(battle.id)
 
             # Deployed battles and allied battles:
             elif self.details.current_country in battle.invader.allies + battle.defender.allies + battle_sides:
                 if self.details.current_country in battle.invader.deployed + battle.defender.deployed:
                     if battle.is_air:
-                        deployed_battles_ground.append(battle.id)
-                    else:
                         deployed_battles_air.append(battle.id)
+                    else:
+                        deployed_battles_ground.append(battle.id)
                 # Allied battles:
                 else:
                     if battle.is_air:
-                        ally_battles_ground.append(battle.id)
-                    else:
                         ally_battles_air.append(battle.id)
                     else:
-                if battle.is_air:
+                        ally_battles_ground.append(battle.id)
-                    other_battles_ground.append(battle.id)
             else:
+                if battle.is_air:
                     other_battles_air.append(battle.id)
+                else:
+                    other_battles_ground.append(battle.id)
 
         ret_battles += (cs_battles_air + cs_battles_ground +
                         deployed_battles_air + deployed_battles_ground +
@@ -814,7 +816,7 @@ class Citizen(CitizenAPI):
                 self.collect_weekly_reward()
                 break
 
-    def fight(self, battle_id: int, side_id: int = None, count: int = None):
+    def fight(self, battle_id: int, side_id: int = None, count: int = None) -> int:
         """Fight in a battle.
 
         Will auto activate booster and travel if allowed to do it and
@@ -824,6 +826,11 @@ class Citizen(CitizenAPI):
         :param count: How many hits to do, if not specified self.should_fight() is called.
         :return: None if no errors while fighting, otherwise error count.
         """
+        if not isinstance(battle_id, int):
+            self.report_error(f"WARNINNG! Parameter battle_id should be 'int', but it is '{type(battle_id).__name__}'")
+            battle_id = int(battle_id)
+        if battle_id not in self.all_battles:
+            self.update_war_info()
         battle = self.all_battles[battle_id]
         zone_id = battle.div[11 if battle.is_air else self.division].battle_zone_id
         if not battle.is_air and self.config.boosters:
@@ -852,7 +859,6 @@ class Citizen(CitizenAPI):
                     if total_damage:
                         self.reporter.report_action("FIGHT", dict(battle=battle_id, side=side_id, dmg=total_damage,
                                                                   air=battle.is_air, hits=total_hits))
-        if error_count:
         return error_count
 
     def _shoot(self, battle_id: int, inv_side: bool, zone_id: int):
@@ -1142,7 +1148,7 @@ class Citizen(CitizenAPI):
                 return self._do_wam_and_employee_work(wam_holding_id, employee_companies)
             else:
                 msg = "I was not able to wam and or employ because:\n{}".format(response)
-                self.reporter.report_action("WORK_WAM_EMPLOYEES", value=msg)
+                self.reporter.report_action("WORK_WAM_EMPLOYEES", response, msg)
                 self.write_log(msg)
         wam_count = self.my_companies.get_total_wam_count()
         if wam_count:
@@ -1882,7 +1888,7 @@ class Citizen(CitizenAPI):
                        r'class="join" title="Join"><span>Join</span></a>', html):
             battle_id = re.search(r'<a href="//www.erepublik.com/en/military/battlefield/(\d+)" '
                                   r'class="join" title="Join"><span>Join</span></a>', html).group(1)
-            ret.update(can_attack=False, battle_id=battle_id)
+            ret.update(can_attack=False, battle_id=int(battle_id))
         elif re.search(r'This war is no longer active.', html):
             ret.update(can_attack=False, ended=True)
         else:
@@ -2038,8 +2044,11 @@ class Citizen(CitizenAPI):
         r = self._post_main_country_post_create(message, max(post_to_wall_as, key=int) if post_to_wall_as else 0)
         return r.json()
 
-    def report_error(self, msg: str = ""):
+    def report_error(self, msg: str = "", is_warning: bool = False):
-        process_error(msg, self.name, sys.exc_info(), self, self.commit_id, False)
+        if is_warning:
+            process_warning(msg, self.name, sys.exc_info(), self, self.commit_id)
+        else:
+            process_error(msg, self.name, sys.exc_info(), self, self.commit_id, None)
 
     def get_battle_top_10(self, battle_id: int) -> Dict[int, List[Tuple[int, int]]]:
         return {}

erepublik/classes.py

@@ -4,7 +4,7 @@ import hashlib
 import random
 import threading
 import time
-from collections import deque
+from collections import deque, defaultdict
 from json import JSONDecodeError, loads, JSONEncoder
 from typing import Any, Dict, List, Union, Mapping, Iterable, Tuple
 
@@ -200,19 +200,19 @@ class SlowRequests(Session):
     timeout = datetime.timedelta(milliseconds=500)
     uas = [
         # Chrome
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.80 Safari/537.36',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.80 Safari/537.36',
         # FireFox
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:70.0) Gecko/20100101 Firefox/70.0',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:70.0) Gecko/20100101 Firefox/70.0',
         'Mozilla/5.0 (X11; Linux x86_64; rv:69.0) Gecko/20100101 Firefox/69.0',
         'Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:67.0) Gecko/20100101 Firefox/67.0',
     ]
     debug = False
 
@@ -1099,17 +1099,25 @@ class BattleDivision:
     def div_end(self) -> bool:
         return utils.now() >= self.end
 
-    def __init__(
+    def __init__(self, **kwargs):
-        self, div_id: int, end: datetime.datetime, epic: bool, inv_pts: int, def_pts: int,
+        """Battle division helper class
+
+        :param kwargs: must contain keys:
+            div_id: int, end: datetime.datetime, epic: bool, inv_pts: int, def_pts: int,
             wall_for: int, wall_dom: float, def_medal: Tuple[int, int], inv_medal: Tuple[int, int]
-    ):
+        """
-        self.battle_zone_id = div_id
+
-        self.end = end
+        self.battle_zone_id = kwargs.get("div_id", 0)
-        self.epic = epic
+        self.end = kwargs.get("end", 0)
-        self.dom_pts = dict({"inv": inv_pts, "def": def_pts})
+        self.epic = kwargs.get("epic", 0)
-        self.wall = dict({"for": wall_for, "dom": wall_dom})
+        self.dom_pts = dict({"inv": kwargs.get("inv_pts", 0), "def": kwargs.get("def_pts", 0)})
-        self.def_medal = {"id": def_medal[0], "dmg": def_medal[1]}
+        self.wall = dict({"for": kwargs.get("wall_for", 0), "dom": kwargs.get("wall_dom", 0)})
-        self.inv_medal = {"id": inv_medal[0], "dmg": inv_medal[1]}
+        self.def_medal = {"id": kwargs.get("def_medal", 0)[0], "dmg": kwargs.get("def_medal", 0)[1]}
+        self.inv_medal = {"id": kwargs.get("inv_medal", 0)[0], "dmg": kwargs.get("inv_medal", 0)[1]}
+
+    @property
+    def id(self):
+        return self.battle_zone_id
 
 
 class Battle:
@@ -1164,7 +1172,7 @@ class Battle:
                 [row.get('id') for row in battle.get('def', {}).get('ally_list') if row['deployed']]
             )
 
-        self.div = {}
+        self.div = defaultdict(BattleDivision)
         for div, data in battle.get('div', {}).items():
             div = int(data.get('div'))
             if data.get('end'):

erepublik/utils.py

@@ -8,7 +8,7 @@ import time
 import traceback
 import unicodedata
 from pathlib import Path
-from typing import Union, Any, List, NoReturn, Mapping
+from typing import Union, Any, List, NoReturn, Mapping, Optional
 
 import pytz
 import requests
@@ -17,7 +17,7 @@ __all__ = ["FOOD_ENERGY", "COMMIT_ID", "COUNTRIES", "erep_tz", 'COUNTRY_LINK',
            "now", "localize_dt", "localize_timestamp", "good_timedelta", "eday_from_date", "date_from_eday",
            "get_sleep_seconds", "interactive_sleep", "silent_sleep",
            "write_silent_log", "write_interactive_log", "get_file", "write_file",
-           "send_email", "normalize_html_json", "process_error", 'report_promo', 'calculate_hit']
+           "send_email", "normalize_html_json", "process_error", "process_warning", 'report_promo', 'calculate_hit']
 
 FOOD_ENERGY = dict(q1=2, q2=4, q3=6, q4=8, q5=10, q6=12, q7=20)
 COMMIT_ID = "7b92e19"
@@ -288,10 +288,43 @@ def normalize_html_json(js: str) -> str:
 
 
 def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commit_id: str = None,
-                  interactive: bool = False):
+                  interactive: Optional[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: Code's version by commit id
+    :type commit_id: str
+    """
+    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_))]
+
+    if interactive:
+        write_interactive_log(log_info)
+    elif interactive is not None:
+        write_silent_log(log_info)
+    trace = inspect.trace()
+    if trace:
+        trace = trace[-1][0].f_locals
+    else:
+        trace = dict()
+    send_email(name, content, citizen, local_vars=trace)
+
+
+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()
@@ -299,19 +332,17 @@ def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commi
     :param commit_id: Code's version by commit id
     """
     type_, value_, traceback_ = exc_info
-    bugtrace = [] if not commit_id else ["Commit id: %s" % commit_id, ]
+    content = [log_info]
-    bugtrace += [str(value_), str(type_), ''.join(traceback.format_tb(traceback_))]
+    if commit_id:
+        content += ["Commit id: %s" % commit_id]
+    content += [str(value_), str(type_), ''.join(traceback.format_tb(traceback_))]
 
-    if interactive:
-        write_interactive_log(log_info)
-    else:
-        write_silent_log(log_info)
     trace = inspect.trace()
     if trace:
         trace = trace[-1][0].f_locals
     else:
         trace = dict()
-    send_email(name, bugtrace, citizen, local_vars=trace)
+    send_email(name, content, citizen, local_vars=trace)
 
 
 def report_promo(kind: str, time_untill: datetime.datetime) -> NoReturn:

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.18.1
+current_version = 0.18.3
 commit = True
 tag = True
 

setup.py

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