Bump version: 0.19.3 → 0.19.4

* bugfix:
  Hey Plato! If You're reading this - fix your variable types and there will be 90% less bugs in Your code!!!
  Some TelegramBot tweaks
  when full energy update citizen info would stop working because trying to get timedelta from now - _last_full_energy_report
  Too broad exception was cought without notifying about actual error - when Telegram isn't enabled

erepublik/__init__.py

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

erepublik/citizen.py

@@ -144,7 +144,6 @@ class Citizen(CitizenAPI):
             return
 
         html = resp.text
-        self.check_for_new_medals(html)
         re_token = re.search(r'var csrfToken = \'(\w{32})\'', html)
         re_login_token = re.search(r'<input type="hidden" id="_token" name="_token" value="(\w{32})">', html)
         if re_token:
@@ -156,7 +155,7 @@ class Citizen(CitizenAPI):
             raise ErepublikException("Something went wrong! Can't find token in page! Exiting!")
         try:
             self.update_citizen_info(resp.text)
-        except:
+        except (AttributeError, json.JSONDecodeError, ValueError, KeyError):
             pass
 
     def _login(self):
@@ -212,15 +211,13 @@ class Citizen(CitizenAPI):
                 return self.get(url, **kwargs)
 
             try:
-                self.update_citizen_info(html=response.text)
-            except:
+                self.update_citizen_info(response.text)
+            except (AttributeError, json.JSONDecodeError, ValueError, KeyError):
                 pass
 
             if self._errors_in_response(response):
                 self.get_csrf_token()
                 self.get(url, **kwargs)
-            else:
-                self.check_for_new_medals(response.text)
 
             self.r = response
         return response
@@ -258,40 +255,38 @@ class Citizen(CitizenAPI):
             elif json:
                 json.update({"_token": self.token})
             response = self.post(url, data=data, json=json, **kwargs)
-        else:
-            self.check_for_new_medals(response.text)
 
         self.r = response
         return response
 
-    def check_for_new_medals(self, html: str):
-        new_medals = re.findall(r'(<div class="home_reward reward achievement">.*?<div class="bottom"></div>\s*</div>)',
-                                html, re.M | re.S | re.I)
+    def check_for_new_medals(self):
+        notifications = self._get_main_citizen_daily_assistant().json()
         data: Dict[Tuple[str, Union[float, str]], Dict[str, Union[int, str, float]]] = {}
-        for medal in new_medals:
-            try:
-                info = re.search(r"<h3>New Achievement</h3>.*?<p.*?>(.*?)</p>.*?"
-                                 r"achievement_recieved.*?<strong>(.*?)</strong>.*?"
-                                 r"<div title=\"(.*?)\">", medal, re.M | re.S)
-                about = info.group(1).strip()
-                title = info.group(2).strip()
-                award_id = re.search(r'"wall_enable_alerts_(\d+)', medal)
-                if award_id:
-                    self._post_main_wall_post_automatic(**{'message': title, 'awardId': award_id.group(1)})
-                reward, currency = info.group(3).strip().split(" ")
-                while not isinstance(reward, float):
-                    try:
-                        reward = float(reward)
-                    except ValueError:
-                        reward = reward[:-1]
+        for medal in notifications.get('notifications', []):
+            if medal.get('details', {}).get('type') == "citizenAchievement":
+                params = medal.get('details', {}).get('achievement')
+                about = medal.get('details').get('description')
+                title = medal.get('title')
+                # award_id = re.search(r'"wall_enable_alerts_(\d+)', medal)
+                # if award_id:
+                #     self._post_main_wall_post_automatic(**{'message': title, 'awardId': award_id.group(1)})
+
+                if params.get('ccValue'):
+                    reward = params.get('ccValue')
+                    currency = "Currency"
+                elif params.get('goldValue'):
+                    reward = params.get('goldValue')
+                    currency = "Gold"
+                else:
+                    reward = params.get('energyValue')
+                    currency = "Energy"
 
                 if (title, reward) not in data:
                     data[(title, reward)] = {'about': about, 'kind': title, 'reward': reward, "count": 1,
-                                             "currency": currency}
+                                             "currency": currency, "params": params}
                 else:
                     data[(title, reward)]['count'] += 1
-            except AttributeError:
-                continue
+            self._post_main_global_alerts_close(medal.get('id'))
         if data:
 
             msgs = ["{count} x {kind}, totaling {} {currency}\n"
@@ -303,13 +298,13 @@ class Citizen(CitizenAPI):
             for info in data.values():
                 self.reporter.report_action("NEW_MEDAL", info)
 
-        levelup = re.search(r"<p>Congratulations, you have reached experience <strong>level (\d+)</strong></p>", html)
-        if levelup:
-            level = levelup.group(1)
-            msg = f"Level up! Current level {level}"
-            self.write_log(msg)
-            self.telegram.report_medal(f"Level *{level}*")
-            self.reporter.report_action("LEVEL_UP", value=level)
+        # levelup = re.search(r"<p>Congratulations, you have reached experience <strong>level (\d+)</strong></p>", html)
+        # if levelup:
+        #     level = levelup.group(1)
+        #     msg = f"Level up! Current level {level}"
+        #     self.write_log(msg)
+        #     self.telegram.report_medal(f"Level *{level}*")
+        #     self.reporter.report_action("LEVEL_UP", value=level)
 
     def update_all(self, force_update=False):
         # Do full update max every 5 min
@@ -324,12 +319,14 @@ class Citizen(CitizenAPI):
         self.update_money()
         self.update_weekly_challenge()
         self.send_state_update()
+        self.check_for_new_medals()
 
     def update_citizen_info(self, html: str = None):
         """
         Gets main page and updates most information about player
         """
         if html is None:
+            self.check_for_new_medals()
             self._get_main()
             return
         ugly_js = re.search(r'"promotions":\s*(\[{?.*?}?])', html).group(1)
@@ -2195,11 +2192,14 @@ class Citizen(CitizenAPI):
         while not isinstance(available_weapons, list):
             available_weapons = self._get_military_show_weapons(battle_id).json()
         weapon_quality = -1
+        weapon_damage = 0
         if not battle.is_air:
             for weapon in available_weapons:
-                if weapon['weaponId'] == 7 and weapon['weaponQuantity'] > 30:
-                    weapon_quality = 7
-                    break
+                try:
+                    if weapon['weaponQuantity'] > 30 and weapon['damage'] > weapon_damage:
+                        weapon_quality = int(weapon['weaponId'])
+                except ValueError:
+                    pass
         return self.change_weapon(battle_id, weapon_quality)
 
     def change_weapon(self, battle_id: int, weapon_quality: int) -> int:

erepublik/classes.py

@@ -524,9 +524,12 @@ Class for unifying eRepublik known endpoints and their required/optional paramet
     def _get_main_citizen_profile_json(self, player_id: int) -> Response:
         return self.get("{}/main/citizen-profile-json/{}".format(self.url, player_id))
 
-    def _get_main_citizen_daily_assistant(self) -> Response:
+    def _get_main_citizen_notifications(self) -> Response:
         return self.get("{}/main/citizenDailyAssistant".format(self.url))
 
+    def _get_main_citizen_daily_assistant(self) -> Response:
+        return self.get("{}/main/citizenNotifications".format(self.url))
+
     def _get_main_city_data_residents(self, city: int, page: int = 1, params: Mapping[str, Any] = None) -> Response:
         if params is None:
             params = {}
@@ -673,6 +676,10 @@ Class for unifying eRepublik known endpoints and their required/optional paramet
         data = dict(_token=self.token, articleId=article_id, amount=amount)
         return self.post("{}/main/donate-article".format(self.url), data=data)
 
+    def _post_main_global_alerts_close(self, alert_id: int) -> Response:
+        data = dict(_token=self.token, alert_id=alert_id)
+        return self.post("{}/main/global-alerts/close".format(self.url), data=data)
+
     def _post_delete_message(self, msg_id: list) -> Response:
         data = {"_token": self.token, "delete_message[]": msg_id}
         return self.post("{}/main/messages-delete".format(self.url), data)
@@ -1242,11 +1249,11 @@ class EnergyToFight:
 
 
 class TelegramBot:
-    __initialized = False
+    __initialized: bool = False
     __queue: List[str]
-    chat_id = 0
-    api_url = ""
-    player_name = ""
+    chat_id: int = 0
+    api_url: str = ""
+    player_name: str = ""
     __thread_stopper: threading.Event
     _last_time: datetime.datetime
     _last_full_energy_report: datetime.datetime
@@ -1257,12 +1264,13 @@ class TelegramBot:
         self._threads = []
         self.__queue = []
         self.__thread_stopper = threading.Event() if stop_event is None else stop_event
+        self._last_full_energy_report = self._next_time = self._last_time = utils.good_timedelta(utils.now(), datetime.timedelta(hours=1))
 
     @property
     def __dict__(self):
-        return dict(chat_id=self.chat_id, api_url=self.api_url, player=self.player_name, last_time=self._last_time,
-                    next_time=self._next_time, queue=self.__queue, initialized=self.__initialized,
-                    has_threads=bool(len(self._threads)))
+        return {'chat_id': self.chat_id, 'api_url': self.api_url, 'player': self.player_name,
+                'last_time': self._last_time, 'next_time': self._next_time, 'queue': self.__queue,
+                'initialized': self.__initialized, 'has_threads': bool(len(self._threads))}
 
     def do_init(self, chat_id: int, token: str, player_name: str = ""):
         self.chat_id = chat_id

erepublik/utils.py

@@ -6,6 +6,7 @@ import sys
 import time
 import traceback
 import unicodedata
+from decimal import Decimal
 from pathlib import Path
 from typing import Any, List, Mapping, NoReturn, Optional, Union
 
@@ -344,6 +345,11 @@ def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commi
     trace = inspect.trace()
     if trace:
         trace = trace[-1][0].f_locals
+        if trace.get('__name__') == '__main__':
+            trace = {'commit_id': trace.get('COMMIT_ID'),
+                     'interactive': trace.get('INTERACTIVE'),
+                     'version': trace.get('__version__'),
+                     'config': trace.get('CONFIG')}
     else:
         trace = dict()
     send_email(name, content, citizen, local_vars=trace)
@@ -393,27 +399,28 @@ def slugify(value, allow_unicode=False) -> str:
 
 
 def calculate_hit(strength: float, rang: int, tp: bool, elite: bool, ne: bool, booster: int = 0,
-                  weapon: int = 200) -> float:
-    base_dmg = 10 * (1 + strength / 400) * (1 + rang / 5) * (1 + weapon / 100)
-    dmg = int(base_dmg * 10 + 5) // 10
+                  weapon: int = 200, is_deploy: bool = False) -> Decimal:
+    dec = 3 if is_deploy else 0
+    base_str = (1 + Decimal(str(round(strength, 3))) / 400)
+    base_rnk = (1 + Decimal(str(rang / 5)))
+    base_wpn = (1 + Decimal(str(weapon / 100)))
+    dmg = 10 * base_str * base_rnk * base_wpn
 
-    booster_multiplier = (100 + booster) / 100
-    booster_dmg = dmg * booster_multiplier
-    dmg = int(booster_dmg * 10 + 5) // 10
+    if elite:
+        dmg = dmg * 11 / 10
 
-    elite = 1.1 if elite else 1
-    elite_dmg = dmg * elite
-    dmg = int(elite_dmg)
+    if tp and rang >= 70:
+        dmg = dmg * (1 + Decimal((rang - 69) / 10))
 
-    legend = 1 if (not tp or rang < 70) else 1 + (rang - 69) / 10
-    legend_dmg = dmg * legend
-    dmg = int(legend_dmg)
+    dmg = dmg * (100 + booster) / 100
 
-    return dmg * (1.1 if ne else 1)
+    if ne:
+        dmg = dmg * 11 / 10
+    return round(dmg, dec)
 
 
-def ground_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_patriot: bool = False,
-                         booster: int = 0, weapon_power: int = 200) -> float:
+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()
     rang = r['military']['militaryData']['ground']['rankNumber']
     strength = r['military']['militaryData']['ground']['strength']
@@ -424,8 +431,8 @@ def ground_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_patr
     return calculate_hit(strength, rang, true_patriot, elite, natural_enemy, booster, weapon_power)
 
 
-def air_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_patriot: bool = False, booster: int = 0,
-                      weapon_power: int = 0) -> float:
+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()
     rang = r['military']['militaryData']['aircraft']['rankNumber']
     elite = r['citizenAttributes']['level'] > 100

requirements_dev.txt

@@ -5,7 +5,7 @@ flake8==3.7.9
 ipython==7.11.1
 isort==4.3.21
 pip==19.3.1
-PyInstaller==3.5
+PyInstaller==3.6
 pytz==2019.3
 requests==2.22.0
 setuptools==44.0.0

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.19.1
+current_version = 0.19.4
 commit = True
 tag = True
 

setup.py

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