Bump version: 0.21.5.6 → 0.21.5.7

erepublik/__init__.py

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

erepublik/access_points.py

@@ -12,8 +12,8 @@ __all__ = ['SlowRequests', 'CitizenAPI']
 
 class SlowRequests(Session):
     last_time: datetime.datetime
-    timeout = datetime.timedelta(milliseconds=500)
-    uas = [
+    timeout: datetime.timedelta = datetime.timedelta(milliseconds=500)
+    uas: List[str] = [
         # Chrome
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36',  # noqa
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',  # noqa
@@ -36,10 +36,12 @@ class SlowRequests(Session):
         'Mozilla/5.0 (X11; Linux x86_64; rv:79.0) Gecko/20100101 Firefox/79.0',
         'Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0',
     ]
-    debug = False
+    debug: bool = False
 
-    def __init__(self):
+    def __init__(self, proxies: Dict[str, str] = None):
         super().__init__()
+        if proxies:
+            self.proxies = proxies
         self.request_log_name = utils.get_file(utils.now().strftime("debug/requests_%Y-%m-%d.log"))
         self.last_time = utils.now()
         self.headers.update({
@@ -132,6 +134,14 @@ class CitizenBaseAPI:
     def _get_main(self) -> Response:
         return self.get(self.url)
 
+    def set_socks_proxy(self, host: str, port: int, username: str = None, password: str = None):
+        url = f'socks5://{username}:{password}@{host}:{port}' if username and password else f'socks5://{host}:{port}'
+        self._req.proxies = dict(http=url, https=url)
+
+    def set_http_proxy(self, host: str, port: int, username: str = None, password: str = None):
+        url = f'http://{username}:{password}@{host}:{port}' if username and password else f'socks5://{host}:{port}'
+        self._req.proxies = dict(http=url)
+
 
 class ErepublikAnniversaryAPI(CitizenBaseAPI):
     def _post_main_collect_anniversary_reward(self) -> Response:
@@ -154,10 +164,10 @@ class ErepublikAnniversaryAPI(CitizenBaseAPI):
         return self.post(f"{self.url}/main/map-rewards-claim", data=data)
 
     def _post_main_wheel_of_fortune_spin(self, cost) -> Response:
-        return self.post(f"{self.url}/wheeloffortune-spin", data={'_token': self.token, "cost": cost})
+        return self.post(f"{self.url}/main/wheeloffortune-spin", data={'_token': self.token, "_currentCost": cost})
 
     def _post_main_wheel_of_fortune_build(self) -> Response:
-        return self.post(f"{self.url}/wheeloffortune-build", data={'_token': self.token})
+        return self.post(f"{self.url}/main/wheeloffortune-build", data={'_token': self.token})
 
 
 class ErepublikArticleAPI(CitizenBaseAPI):

erepublik/citizen.py

@@ -6,7 +6,7 @@ from decimal import Decimal
 from itertools import product
 from threading import Event
 from time import sleep
-from typing import Any, Callable, Dict, List, NoReturn, Optional, Set, Tuple, Union
+from typing import Any, Dict, List, NoReturn, Optional, Set, Tuple, Union
 
 from requests import HTTPError, RequestException, Response
 
@@ -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
@@ -675,9 +683,7 @@ class CitizenAnniversary(BaseCitizen):
             _write_spin_data(current_cost, r.get('account'),
                              base.get('prizes').get('prizes').get(str(r.get('result'))).get('tooltip'))
         else:
-            is_cost: Callable[[], bool] = lambda: (max_cost != current_cost if max_cost else True)
-            is_count: Callable[[], bool] = lambda: (spin_count != current_count if spin_count else True)
-            while is_cost() or is_count():
+            while max_cost >= current_cost if max_cost else spin_count >= current_count if spin_count else False:
                 r = self._spin_wheel_of_loosing(current_cost)
                 current_count += 1
                 current_cost = r.get('cost')
@@ -686,8 +692,8 @@ class CitizenAnniversary(BaseCitizen):
 
     def _spin_wheel_of_loosing(self, current_cost: int) -> Dict[str, Any]:
         r = self._post_main_wheel_of_fortune_spin(current_cost).json()
-        self.details.cc = r.get('account')
-        return r.get('result')
+        self.details.cc = float(Decimal(r.get('account')))
+        return r
 
 
 class CitizenTravel(BaseCitizen):
@@ -874,6 +880,8 @@ class CitizenCompanies(BaseCitizen):
             self.my_companies.prepare_holdings(utils.json.loads(have_holdings.group(1)))
             self.my_companies.prepare_companies(utils.json.loads(have_companies.group(1)))
 
+        self.reporter.report_action('COMPANIES', json_val=self.my_companies.as_dict)
+
     def assign_company_to_holding(self, company: classes.Company, holding: classes.Holding) -> Response:
         """
         Assigns factory to new holding
@@ -1138,7 +1146,6 @@ class CitizenEconomy(CitizenTravel):
         self.details.gold = float(response.json().get("gold").get("value"))
         if response.json().get('error'):
             self._report_action("BUY_GOLD", "Unable to buy gold!", kwargs=response.json())
-            self.stop_threads.wait()
             return False
         else:
             self._report_action('BUY_GOLD', f'New amount {self.details.cc}cc, {self.details.gold}g',
@@ -1380,6 +1387,7 @@ class CitizenMilitary(CitizenTravel):
                 try:
                     if weapon['weaponQuantity'] > 30 and weapon['weaponInfluence'] > weapon_damage:
                         weapon_quality = int(weapon['weaponId'])
+                        weapon_damage = weapon['weaponInfluence']
                 except ValueError:
                     pass
         return self.change_weapon(battle, weapon_quality, division)
@@ -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:
@@ -1615,7 +1623,7 @@ class CitizenMilitary(CitizenTravel):
         :param battle: Battle battle to fight in
         :type battle: Battle
         :param side: BattleSide or None. Battle side to fight in, If side not == invader id or not in invader deployed
-                                     allies list, then defender's side is chosen
+        allies list, then defender's side is chosen
         :type side: BattleSide
         :param count: How many hits to do, if not specified self.should_fight() is called.
         :type count: int
@@ -1654,11 +1662,11 @@ class CitizenMilitary(CitizenTravel):
                     self.write_log("Hits: {:>4} | Damage: {}".format(total_hits, total_damage))
                     ok_to_fight = False
                     if total_damage:
-                        self.reporter.report_action('FIGHT', dict(battle_id=battle.id, side=side, dmg=total_damage,
-                                                                  air=battle.has_air, hits=total_hits,
-                                                                  round=battle.zone_id))
-                        self.reporter.report_action("FIGHT", dict(battle=str(battle), side=str(side), dmg=total_damage,
-                                                                  air=battle.has_air, hits=total_hits))
+                        self.reporter.report_fighting(battle, not side.is_defender, division, total_damage, total_hits)
+                        # self.reporter.report_action('FIGHT', dict(battle_id=battle.id, side=side, dmg=total_damage,
+                        #                                           air=battle.has_air, hits=total_hits,
+                        #                                           round=battle.zone_id,
+                        #                                           extra=dict(battle=battle, side=side)))
         return error_count
 
     def _shoot(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide):
@@ -1678,14 +1686,17 @@ class CitizenMilitary(CitizenTravel):
         damage = 0
         err = False
         if r_json.get("error"):
-            if r_json.get("message") == "SHOOT_LOCKOUT" or r_json.get("message") == "ZONE_INACTIVE":
+            if r_json.get("message") == "SHOOT_LOCKOUT":
                 pass
             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!!")
                 return 0, 10, 0
-            elif r_json.get("message") == "FIGHT_DISABLED":
+            elif r_json.get("message") == "ZONE_INACTIVE":
+                self.write_log("Wrong division!!")
+                return 0, 10, 0
+            elif r_json.get("message") in ["FIGHT_DISABLED", "DEPLOYMENT_MODE"]:
                 self._post_main_profile_update('options',
                                                params='{"optionName":"enable_web_deploy","optionValue":"off"}')
                 self.set_default_weapon(battle, division)
@@ -1906,7 +1917,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:
@@ -1990,7 +2001,8 @@ class CitizenPolitics(BaseCitizen):
         self._report_action('POLITIC_PARTY_PRESIDENT', 'Applied for party president elections')
         return self._get_candidate_party(self.politics.party_slug)
 
-    def get_country_president_election_result(self, country: constants.Country, year: int, month: int) -> Dict[str, int]:
+    def get_country_president_election_result(self, country: constants.Country, year: int, month: int) -> Dict[
+        str, int]:
         timestamp = int(constants.erep_tz.localize(datetime(year, month, 5)).timestamp())
         resp = self._get_presidential_elections(country.id, timestamp)
         candidates = re.findall(r'class="candidate_info">(.*?)</li>', resp.text, re.S | re.M)

erepublik/classes.py

@@ -3,7 +3,7 @@ import hashlib
 import threading
 import weakref
 from decimal import Decimal
-from typing import Any, Dict, List, NamedTuple, Optional, Tuple, Union
+from typing import Any, Dict, List, NamedTuple, Optional, Tuple, Union, NoReturn
 
 from requests import Response, Session, post
 
@@ -28,13 +28,23 @@ class Holding:
     id: int
     region: int
     companies: List["Company"]
+    name: str
     _citizen = weakref.ReferenceType
 
-    def __init__(self, _id: int, region: int, citizen):
+    def __init__(self, _id: int, region: int, citizen, name: str = None):
         self._citizen = weakref.ref(citizen)
         self.id: int = _id
         self.region: int = region
         self.companies: List["Company"] = list()
+        if name:
+            self.name = name
+        else:
+            name = f"Holding (#{self.id}) with {len(self.companies)} "
+            if len(self.companies) == 1:
+                name += "company"
+            else:
+                name += "companies"
+            self.name = name
 
     @property
     def wam_count(self) -> int:
@@ -48,7 +58,7 @@ class Holding:
     def employable_companies(self) -> List["Company"]:
         return [company for company in self.companies if company.preset_works]
 
-    def add_company(self, company: "Company"):
+    def add_company(self, company: "Company") -> NoReturn:
         self.companies.append(company)
         self.companies.sort()
 
@@ -62,7 +72,7 @@ class Holding:
                 wrm += company.raw_usage
         return dict(frm=frm, wrm=wrm)
 
-    def get_wam_companies(self, raw_factory: bool = None):
+    def get_wam_companies(self, raw_factory: bool = None) -> Optional[List["Company"]]:
         raw = []
         factory = []
         for company in self.wam_companies:
@@ -80,7 +90,7 @@ class Holding:
         else:
             raise ErepublikException("raw_factory should be True/False/None")
 
-    def __str__(self):
+    def __str__(self) -> str:
         name = f"Holding (#{self.id}) with {len(self.companies)} "
         if len(self.companies) % 10 == 1:
             name += "company"
@@ -92,8 +102,9 @@ class Holding:
         return str(self)
 
     @property
-    def as_dict(self):
-        return dict(name=str(self), id=self.id, region=self.region, companies=self.companies, wam_count=self.wam_count)
+    def as_dict(self) -> Dict[str, Union[str, int, List[Dict[str, Union[str, int, bool, float, Decimal]]]]]:
+        return dict(name=self.name, id=self.id, region=self.region,
+                    companies=[c.as_dict for c in self.companies], wam_count=self.wam_count)
 
     @property
     def citizen(self):
@@ -203,7 +214,7 @@ class Company:
         return str(self)
 
     @property
-    def as_dict(self):
+    def as_dict(self) -> Dict[str, Union[str, int, bool, float, Decimal]]:
         return dict(name=str(self), holding=self.holding.id, id=self.id, quality=self.quality, is_raw=self.is_raw,
                     raw_usage=self.raw_usage, products_made=self.products_made, wam_enabled=self.wam_enabled,
                     can_wam=self.can_wam, cannot_wam_reason=self.cannot_wam_reason, industry=self.industry,
@@ -219,7 +230,7 @@ class Company:
         return self.holding.citizen._post_economy_upgrade_company(self.id, level, self.holding.citizen.details.pin)
 
     @property
-    def holding(self):
+    def holding(self) -> Holding:
         return self._holding()
 
 
@@ -245,10 +256,10 @@ class MyCompanies:
         for holding in holdings.values():
             if holding.get('id') not in self.holdings:
                 self.holdings.update({
-                    int(holding.get('id')): Holding(holding['id'], holding['region_id'], self.citizen)
+                    int(holding.get('id')): Holding(holding['id'], holding['region_id'], self.citizen, holding['name'])
                 })
         if not self.holdings.get(0):
-            self.holdings.update({0: Holding(0, 0, self.citizen)})  # unassigned
+            self.holdings.update({0: Holding(0, 0, self.citizen, 'Unassigned')})  # unassigned
 
     def prepare_companies(self, companies: Dict[str, Dict[str, Any]]):
         """
@@ -300,9 +311,11 @@ class MyCompanies:
         self.companies.clear()
 
     @property
-    def as_dict(self):
+    def as_dict(self) -> Dict[str, Union[str, int, datetime.datetime, Dict[str, Dict[str, Union[str, int, List[Dict[str, Union[str, int, bool, float, Decimal]]]]]]]]:
         return dict(name=str(self), work_units=self.work_units, next_ot_time=self.next_ot_time,
-                    ff_lockdown=self.ff_lockdown, holdings=self.holdings, company_count=len(self.companies))
+                    ff_lockdown=self.ff_lockdown,
+                    holdings={str(hi): h.as_dict for hi, h in self.holdings.items()},
+                    company_count=len(self.companies))
 
     @property
     def citizen(self):
@@ -438,24 +451,25 @@ class Energy:
 
 
 class Details:
-    xp = 0
-    cc = 0
-    pp = 0
-    pin = None
-    gold = 0
+    xp: int = 0
+    cc: float = 0
+    pp: int = 0
+    pin: str = None
+    gold: float = 0
     next_pp: List[int] = None
-    citizen_id = 0
+    citizen_id: int = 0
     citizenship: constants.Country
-    current_region = 0
+    current_region: int = 0
     current_country: constants.Country
-    residence_region = 0
+    residence_region: int = 0
     residence_country: constants.Country
-    daily_task_done = False
-    daily_task_reward = False
-    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, }
+    daily_task_done: bool = False
+    daily_task_reward: bool = False
+    mayhem_skills: Dict[int, int]
 
     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}
 
     @property
     def xp_till_level_up(self):
@@ -551,7 +565,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
@@ -618,6 +632,12 @@ class Reporter:
         else:
             self.__to_update.append(json_data)
 
+    def report_fighting(self, battle: "Battle", invader: bool, division: "BattleDivision", damage: float, hits: int):
+        side = battle.invader if invader else battle.defender
+        self.report_action('FIGHT', dict(battle_id=battle.id, side=side, dmg=damage,
+                                         air=battle.has_air, hits=hits,
+                                         round=battle.zone_id, extra=dict(battle=battle, side=side, division=division)))
+
     def report_promo(self, kind: str, time_until: datetime.datetime):
         self._req.post(f"{self.url}/promos/add/", data=dict(kind=kind, time_untill=time_until))
 
@@ -629,7 +649,7 @@ class Reporter:
         except:  # noqa
             return []
 
-    def fetch_tasks(self) -> List[str, Tuple[Any]]:
+    def fetch_tasks(self) -> List[Union[str, Tuple[Any]]]:
         try:
             task_response = self._req.get(f'{self.url}/api/v1/command',
                                           params=dict(citizen=self.citizen_id, key=self.key))

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
-        if trace_local_vars.get('__name__') == '__main__':
-            local_vars = {'commit_id': trace_local_vars.get('COMMIT_ID'),
-                          'interactive': trace_local_vars.get('INTERACTIVE'),
-                          'version': trace_local_vars.get('__version__'),
-                          'config': trace_local_vars.get('CONFIG')}
+        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)

requirements_dev.txt

@@ -7,11 +7,12 @@ isort==5.5.3
 pip==20.2.3
 PyInstaller==4.0
 pytz==2020.1
-pytest==6.0.2
+pytest==6.1.0
 responses==0.12.0
 setuptools==50.3.0
 Sphinx==3.2.1
 requests==2.24.0
+PySocks==1.7.1
 tox==3.20.0
 twine==3.2.0
 watchdog==0.10.3

setup.cfg

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

setup.py

@@ -11,11 +11,18 @@ with open('README.rst') as readme_file:
 with open('HISTORY.rst') as history_file:
     history = history_file.read()
 
-requirements = ['pytz==2020.1', 'requests==2.24.0']
+requirements = [
+    'pytz==2020.1',
+    'requests==2.24.0',
+    'PySocks==1.7.1'
+]
 
 setup_requirements = []
 
-test_requirements = []
+test_requirements = [
+    "pytest==6.1.0",
+    "responses==0.12.0"
+]
 
 setup(
     author="Eriks Karls",
@@ -43,6 +50,6 @@ setup(
     test_suite='tests',
     tests_require=test_requirements,
     url='https://github.com/eeriks/erepublik/',
-    version='0.21.4',
+    version='0.21.5.7',
     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.recoverable = 2950
-        self.citizen.energy.interval = 30
-        self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
-        self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
-        self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.energy.recovered = 3000
+            self.citizen.energy.recoverable = 2950
+            self.citizen.energy.interval = 30
+            self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
+            self.citizen.my_companies.ff_lockdown = 160
+            self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
+            self.citizen.my_companies.ff_lockdown = 0
 
-        # Level up reachable
-        self.citizen.details.xp = 24400
-        self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
-        self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
-        self.citizen.my_companies.ff_lockdown = 0
+            # Level up reachable
+            self.citizen.details.xp = 24400
+            self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
+            self.citizen.my_companies.ff_lockdown = 160
+            self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
+            self.citizen.my_companies.ff_lockdown = 0
 
-        self.citizen.details.xp = 21000
-        self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
-        self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
-        self.citizen.my_companies.ff_lockdown = 0
-        self.citizen.details.pp = 80
+            self.citizen.details.xp = 21000
+            self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
+            self.citizen.my_companies.ff_lockdown = 160
+            self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
+            self.citizen.my_companies.ff_lockdown = 0
+            self.citizen.details.pp = 80
 
-        # All-in (type = all-in and full ff)
-        self.citizen.config.all_in = True
-        self.assertEqual(self.citizen.should_fight(), (595, 'Fighting all-in. Doing 595 hits', False))
-        self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (
-            435, 'Fight count modified (old count: 595 | FF: 595 | WAM ff_lockdown: 160 | New count: 435)', False
-        ))
-        self.citizen.my_companies.ff_lockdown = 0
+            # All-in (type = all-in and full ff)
+            self.citizen.config.all_in = True
+            self.assertEqual(self.citizen.should_fight(), (595, 'Fighting all-in. Doing 595 hits', False))
+            self.citizen.my_companies.ff_lockdown = 160
+            self.assertEqual(self.citizen.should_fight(), (
+                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.config.air = True
-        self.citizen.energy.recoverable = 1000
-        self.assertEqual(self.citizen.should_fight(), (400, 'Fighting all-in in AIR. Doing 400 hits', False))
-        self.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (
-            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.config.all_in = False
+            self.citizen.config.air = True
+            self.citizen.energy.recoverable = 1000
+            self.assertEqual(self.citizen.should_fight(), (400, 'Fighting all-in in AIR. Doing 400 hits', False))
+            self.citizen.my_companies.ff_lockdown = 160
+            self.assertEqual(self.citizen.should_fight(), (
+                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.config.all_in = False
 
-        self.citizen.config.next_energy = True
-        self.citizen.energy.limit = 5000
-        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.citizen.my_companies.ff_lockdown = 160
-        self.assertEqual(self.citizen.should_fight(), (
-            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.energy.limit = 3000
-        self.citizen.details.next_pp = [19250, 20000]
-        self.citizen.config.next_energy = False
+            self.citizen.config.next_energy = True
+            self.citizen.energy.limit = 5000
+            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.citizen.my_companies.ff_lockdown = 160
+            self.assertEqual(self.citizen.should_fight(), (
+                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.energy.limit = 3000
+            self.citizen.details.next_pp = [19250, 20000]
+            self.citizen.config.next_energy = False
 
-        # 1h worth of energy
-        self.citizen.energy.recoverable = 2910
-        self.assertEqual(self.citizen.should_fight(), (30, 'Fighting for 1h energy. Doing 30 hits', True))
+            # 1h worth of energy
+            self.citizen.energy.recoverable = 2910
+            self.assertEqual(self.citizen.should_fight(), (30, 'Fighting for 1h energy. Doing 30 hits', True))