Bump version: 0.21.4.5 → 0.21.4.6

erepublik/__init__.py

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

erepublik/citizen.py

@@ -624,8 +624,16 @@ class BaseCitizen(access_points.CitizenAPI):
                 self.sleep(5 * 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 ss having maintenance. Sleeping for 5 minutes")
+            self.sleep(5 * 60)
+            return True
         return bool(re.search(r'body id="error"|Internal Server Error|'
-                              r'CSRF attack detected|meta http-equiv="refresh"|not_authenticated', response.text))
+                              r'CSRF attack detected|meta http-equiv="refresh"|'
+                              r'not_authenticated', response.text))
 
     def _report_action(self, action: str, msg: str, **kwargs: Optional[Dict[str, Any]]):
         """ Report action to all available reporting channels
@@ -1523,7 +1531,7 @@ class CitizenMilitary(CitizenTravel):
                 if not division.terrain and is_start_ok and not division.div_end:
                     if division.is_air and self.config.air:
                         division_medals = self.get_battle_round_data(division)
-                        medal = division_medals[self.details.citizenship == division.battle.is_defender.country]
+                        medal = division_medals[self.details.citizenship == division.battle.defender.country]
                         if not medal:
                             air_divs.append((0, division))
                         else:
@@ -1532,7 +1540,7 @@ class CitizenMilitary(CitizenTravel):
                         if not division.div == self.division and not self.maverick:
                             continue
                         division_medals = self.get_battle_round_data(division)
-                        medal = division_medals[self.details.citizenship == division.battle.is_defender.country]
+                        medal = division_medals[self.details.citizenship == division.battle.defender.country]
                         if not medal:
                             ground_divs.append((0, division))
                         else:
@@ -1906,7 +1914,7 @@ class CitizenMilitary(CitizenTravel):
                                                battleZoneId=division.id, type="damage")
         r_json = r.json()
         return (r_json.get(str(battle.invader.id)).get("fighterData"),
-                r_json.get(str(battle.is_defender.id)).get("fighterData"))
+                r_json.get(str(battle.defender.id)).get("fighterData"))
 
     def schedule_attack(self, war_id: int, region_id: int, region_name: str, at_time: datetime):
         if at_time:

erepublik/classes.py

@@ -551,7 +551,7 @@ class Reporter:
         self.url = "https://api.erep.lv"
         self._req.headers.update({"user-agent": "eRepublik Script Reporter v3",
                                   'erep-version': utils.__version__,
-                                  'erep-user-id': self.citizen_id,
+                                  'erep-user-id': str(self.citizen_id),
                                   'erep-user-name': self.citizen.name})
         self.__to_update = []
         self.__registered: bool = False

erepublik/utils.py

@@ -278,14 +278,13 @@ def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commi
     elif interactive is not None:
         write_silent_log(log_info)
     trace = inspect.trace()
-    local_vars = None
     if trace:
-        trace_local_vars = trace[-1][0].f_locals
+        local_vars = trace[-1][0].f_locals
-        if trace_local_vars.get('__name__') == '__main__':
+        if local_vars.get('__name__') == '__main__':
-            local_vars = {'commit_id': trace_local_vars.get('COMMIT_ID'),
+            local_vars.update({'commit_id': local_vars.get('COMMIT_ID'),
-                          'interactive': trace_local_vars.get('INTERACTIVE'),
+                               'interactive': local_vars.get('INTERACTIVE'),
-                          'version': trace_local_vars.get('__version__'),
+                               'version': local_vars.get('__version__'),
-                          'config': trace_local_vars.get('CONFIG')}
+                               'config': local_vars.get('CONFIG')})
     else:
         local_vars = dict()
     send_email(name, content, citizen, local_vars=local_vars)

setup.cfg

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

setup.py

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

tests/test_erepublik_script.py

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 """Tests for `erepublik` package."""
+from typing import Callable
 
 from erepublik import Citizen
 
@@ -65,6 +66,7 @@ class TestErepublik(unittest.TestCase):
         self.assertEqual(self.citizen.next_reachable_energy, 0)
 
     def test_should_fight(self):
+        is_wc_close: Callable[[], bool] = lambda: self.citizen.max_time_till_full_ff > self.citizen.time_till_week_change
         self.citizen.config.fight = False
         self.assertEqual(self.citizen.should_fight(), (0, "Fighting not allowed!", False))
 
@@ -73,62 +75,63 @@ class TestErepublik(unittest.TestCase):
         # Level up
         self.citizen.energy.limit = 3000
         self.citizen.details.xp = 24705
-        self.assertEqual(self.citizen.should_fight(), (0, 'Level up', False))
+        if not is_wc_close:
+            self.assertEqual(self.citizen.should_fight(), (0, 'Level up', False))
 
-        self.citizen.energy.recovered = 3000
+            self.citizen.energy.recovered = 3000
-        self.citizen.energy.recoverable = 2950
+            self.citizen.energy.recoverable = 2950
-        self.citizen.energy.interval = 30
+            self.citizen.energy.interval = 30
-        self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
+            self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
-        self.citizen.my_companies.ff_lockdown = 160
+            self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
+            self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.my_companies.ff_lockdown = 0
 
-        # Level up reachable
+            # Level up reachable
-        self.citizen.details.xp = 24400
+            self.citizen.details.xp = 24400
-        self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
+            self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
-        self.citizen.my_companies.ff_lockdown = 160
+            self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
+            self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.my_companies.ff_lockdown = 0
 
-        self.citizen.details.xp = 21000
+            self.citizen.details.xp = 21000
-        self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
+            self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
-        self.citizen.my_companies.ff_lockdown = 160
+            self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
+            self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.my_companies.ff_lockdown = 0
-        self.citizen.details.pp = 80
+            self.citizen.details.pp = 80
 
-        # All-in (type = all-in and full ff)
+            # All-in (type = all-in and full ff)
-        self.citizen.config.all_in = True
+            self.citizen.config.all_in = True
-        self.assertEqual(self.citizen.should_fight(), (595, 'Fighting all-in. Doing 595 hits', False))
+            self.assertEqual(self.citizen.should_fight(), (595, 'Fighting all-in. Doing 595 hits', False))
-        self.citizen.my_companies.ff_lockdown = 160
+            self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (
+            self.assertEqual(self.citizen.should_fight(), (
-            435, 'Fight count modified (old count: 595 | FF: 595 | WAM ff_lockdown: 160 | New count: 435)', False
+                435, 'Fight count modified (old count: 595 | FF: 595 | WAM ff_lockdown: 160 | New count: 435)', False
-        ))
+            ))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.my_companies.ff_lockdown = 0
 
-        self.citizen.config.air = True
+            self.citizen.config.air = True
-        self.citizen.energy.recoverable = 1000
+            self.citizen.energy.recoverable = 1000
-        self.assertEqual(self.citizen.should_fight(), (400, 'Fighting all-in in AIR. Doing 400 hits', False))
+            self.assertEqual(self.citizen.should_fight(), (400, 'Fighting all-in in AIR. Doing 400 hits', False))
-        self.citizen.my_companies.ff_lockdown = 160
+            self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (
+            self.assertEqual(self.citizen.should_fight(), (
-            240, 'Fight count modified (old count: 400 | FF: 400 | WAM ff_lockdown: 160 | New count: 240)', False
+                240, 'Fight count modified (old count: 400 | FF: 400 | WAM ff_lockdown: 160 | New count: 240)', False
-        ))
+            ))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.my_companies.ff_lockdown = 0
-        self.citizen.config.all_in = False
+            self.citizen.config.all_in = False
 
-        self.citizen.config.next_energy = True
+            self.citizen.config.next_energy = True
-        self.citizen.energy.limit = 5000
+            self.citizen.energy.limit = 5000
-        self.citizen.details.next_pp = [100, 150, 250, 400, 500]
+            self.citizen.details.next_pp = [100, 150, 250, 400, 500]
-        self.assertEqual(self.citizen.should_fight(), (320, 'Fighting for +1 energy. Doing 320 hits', False))
+            self.assertEqual(self.citizen.should_fight(), (320, 'Fighting for +1 energy. Doing 320 hits', False))
-        self.citizen.my_companies.ff_lockdown = 160
+            self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (
+            self.assertEqual(self.citizen.should_fight(), (
-            160, 'Fight count modified (old count: 320 | FF: 400 | WAM ff_lockdown: 160 | New count: 160)', False
+                160, 'Fight count modified (old count: 320 | FF: 400 | WAM ff_lockdown: 160 | New count: 160)', False
-        ))
+            ))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.my_companies.ff_lockdown = 0
-        self.citizen.energy.limit = 3000
+            self.citizen.energy.limit = 3000
-        self.citizen.details.next_pp = [19250, 20000]
+            self.citizen.details.next_pp = [19250, 20000]
-        self.citizen.config.next_energy = False
+            self.citizen.config.next_energy = False
 
-        # 1h worth of energy
+            # 1h worth of energy
-        self.citizen.energy.recoverable = 2910
+            self.citizen.energy.recoverable = 2910
-        self.assertEqual(self.citizen.should_fight(), (30, 'Fighting for 1h energy. Doing 30 hits', True))
+            self.assertEqual(self.citizen.should_fight(), (30, 'Fighting for 1h energy. Doing 30 hits', True))