Bump version: 0.23.2.3 → 0.23.2.4

HISTORY.rst

@@ -2,8 +2,22 @@
 History
 =======
 
+0.23.2 (2020-12-01)
+-------------------
+* Added concurrency checks to guard against simultaneous fighting/wam'ing/traveling
+* For concurrency checking use `utils.wait_for_lock` decorator
+
+0.23.1 (2020-12-01)
+-------------------
+* Separated battle finding logic from CitizenMilitary.find_battle_and_fight method
+* Base dmg calculations
+* Get max hit value for divisions on current side
+* Added method to get division stats
+* Wheel of fortune updates
+
 0.23.0 (2020-11-26)
 -------------------
+* ***0.23 - last supported version for Python 3.7.***
 * Added `Config.maverick` switch, to allow/deny automated fighting in non native divisions if the player has MaverickPack
 * Added `CitizenMedia.get_article(article_id:int)` method to get article data
 * Added `CitizenMedia.delete_article(article_id:int)` method to delete article

erepublik/__init__.py

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

erepublik/access_points.py

@@ -87,9 +87,7 @@ class SlowRequests(Session):
 
             body = "[{dt}]\tURL: '{url}'\tMETHOD: {met}\tARGS: {args}\n".format(dt=utils.now().strftime("%F %T"),
                                                                                 url=url, met=method, args=args)
-            utils.get_file(self.request_log_name)
+            utils.write_file(self.request_log_name, body)
-            with open(self.request_log_name, 'ab') as file:
-                file.write(body.encode("UTF-8"))
 
     def _log_response(self, url, resp, redirect: bool = False):
         from erepublik import Citizen
@@ -115,6 +113,7 @@ class SlowRequests(Session):
             filename = 'debug/requests/{time}_{name}{extra}.{ext}'.format(**file_data)
             with open(utils.get_file(filename), 'wb') as f:
                 f.write(resp.text.encode('utf-8'))
+        pass
 
 
 class CitizenBaseAPI:

erepublik/citizen.py

@@ -35,12 +35,14 @@ class BaseCitizen(access_points.CitizenAPI):
     eday: int = 0
     wheel_of_fortune: bool
 
+    debug: bool = False
     config: classes.Config = None
     energy: classes.Energy = None
     details: classes.Details = None
     politics: classes.Politics = None
     reporter: classes.Reporter = None
     stop_threads: Event = None
+    concurrency_available: Event = None
     telegram: classes.TelegramBot = None
 
     r: Response = None
@@ -57,6 +59,8 @@ class BaseCitizen(access_points.CitizenAPI):
         self.my_companies = classes.MyCompanies(self)
         self.reporter = classes.Reporter(self)
         self.stop_threads = Event()
+        self.concurrency_available = Event()
+        self.concurrency_available.set()
         self.telegram = classes.TelegramBot(stop_event=self.stop_threads)
 
         self.config.email = email
@@ -421,6 +425,10 @@ class BaseCitizen(access_points.CitizenAPI):
         else:
             sleep(seconds)
 
+    def set_debug(self, debug: bool):
+        self.debug = bool(debug)
+        self._req.debug = bool(debug)
+
     def to_json(self, indent: bool = False) -> str:
         return utils.json.dumps(self, cls=classes.MyJSONEncoder, indent=4 if indent else None)
 
@@ -928,6 +936,7 @@ class CitizenCompanies(BaseCitizen):
     def work_as_manager_in_holding(self, holding: classes.Holding) -> Optional[Dict[str, Any]]:
         return self._work_as_manager(holding)
 
+    @utils.wait_for_lock
     def _work_as_manager(self, wam_holding: classes.Holding) -> Optional[Dict[str, Any]]:
         if self.restricted_ip:
             return None
@@ -1017,7 +1026,8 @@ class CitizenEconomy(CitizenTravel):
             ret.update({house_quality: till})
         return ret
 
-    def buy_and_activate_house(self, q: int) -> Dict[int, datetime]:
+    @utils.wait_for_lock
+    def buy_and_activate_house(self, q: int) -> Optional[Dict[int, datetime]]:
         original_region = self.details.current_country, self.details.current_region
         ok_to_activate = False
         inv = self.get_inventory()
@@ -1058,7 +1068,9 @@ class CitizenEconomy(CitizenTravel):
         house_durability = self.check_house_durability()
         for q, active_till in house_durability.items():
             if utils.good_timedelta(active_till, - timedelta(hours=48)) <= self.now or forced:
-                house_durability = self.buy_and_activate_house(q)
+                durability = self.buy_and_activate_house(q)
+                if durability:
+                    house_durability = durability
         return house_durability
 
     def activate_house(self, quality: int) -> bool:
@@ -1178,7 +1190,8 @@ class CitizenEconomy(CitizenTravel):
             self._report_action("BOUGHT_PRODUCTS", json_ret.get('message'), kwargs=json_ret)
         return json_ret
 
-    def buy_market_offer(self, offer: OfferItem, amount: int = None) -> dict:
+    @utils.wait_for_lock
+    def buy_market_offer(self, offer: OfferItem, amount: int = None) -> Optional[Dict[str, Any]]:
         if amount is None or amount > offer.amount:
             amount = offer.amount
         traveled = False
@@ -1673,46 +1686,59 @@ class CitizenMilitary(CitizenTravel):
     def has_battle_contribution(self):
         return bool(self.__last_war_update_data.get("citizen_contribution", []))
 
+    def find_battle_to_fight(self, silent: bool = False) -> Tuple[
+        classes.Battle, classes.BattleDivision, classes.BattleSide]:
+        self.update_war_info()
+        for battle in self.sorted_battles(self.config.sort_battles_time):
+            if not isinstance(battle, classes.Battle):
+                continue
+            battle_zone: Optional[classes.BattleDivision] = None
+            for div in battle.div.values():
+                if div.terrain == 0:
+                    if div.div_end:
+                        continue
+                    if self.config.air and div.is_air:
+                        battle_zone = div
+                        break
+                    elif self.config.ground and not div.is_air and (
+                        div.div == self.division or (self.maverick and self.config.maverick)):
+                        battle_zone = div
+                        break
+                    else:
+                        continue
+            if not battle_zone:
+                continue
+            allies = battle.invader.deployed + battle.defender.deployed + [battle.invader.country,
+                                                                           battle.defender.country]
+
+            travel_needed = self.details.current_country not in allies
+
+            if battle.is_rw:
+                side = battle.defender if self.config.rw_def_side else battle.invader
+            else:
+                defender_side = self.details.current_country in battle.defender.allies + [battle.defender.country, ]
+                side = battle.defender if defender_side else battle.invader
+
+            if not silent:
+                self.write_log(battle)
+
+            travel = (self.config.travel_to_fight and self.should_travel_to_fight() or self.config.force_travel) \
+                if travel_needed else True
+
+            if not travel:
+                continue
+            yield battle, battle_zone, side
+
     def find_battle_and_fight(self):
         if self.should_fight()[0]:
             self.write_log("Checking for battles to fight in...")
-            for battle in self.sorted_battles(self.config.sort_battles_time):
+            for battle, division, side in self.find_battle_to_fight():
-                if not isinstance(battle, classes.Battle):
+
-                    continue
-                battle_zone: Optional[classes.BattleDivision] = None
-                for div in battle.div.values():
-                    if div.terrain == 0:
-                        if div.div_end:
-                            continue
-                        if self.config.air and div.is_air:
-                            battle_zone = div
-                            break
-                        elif self.config.ground and not div.is_air and (div.div == self.division or self.maverick):
-                            battle_zone = div
-                            break
-                        else:
-                            continue
-                if not battle_zone:
-                    continue
                 allies = battle.invader.deployed + battle.defender.deployed + [battle.invader.country,
                                                                                battle.defender.country]
 
                 travel_needed = self.details.current_country not in allies
 
-                if battle.is_rw:
-                    side = battle.defender if self.config.rw_def_side else battle.invader
-                else:
-                    defender_side = self.details.current_country in battle.defender.allies + [battle.defender.country, ]
-                    side = battle.defender if defender_side else battle.invader
-
-                self.write_log(battle)
-
-                travel = (self.config.travel_to_fight and self.should_travel_to_fight() or self.config.force_travel) \
-                    if travel_needed else True
-
-                if not travel:
-                    continue
-
                 if battle.start > self.now:
                     self.sleep(utils.get_sleep_seconds(battle.start))
 
@@ -1728,14 +1754,16 @@ class CitizenMilitary(CitizenTravel):
 
                     if not self.travel_to_battle(battle, countries_to_travel):
                         break
-                if self.change_division(battle, battle_zone):
+
-                    self.set_default_weapon(battle, battle_zone)
+                if self.change_division(battle, division):
-                    self.fight(battle, battle_zone, side)
+                    self.set_default_weapon(battle, division)
+                    self.fight(battle, division, side)
                     self.travel_to_residence()
                     break
 
+    @utils.wait_for_lock
     def fight(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide = None,
-              count: int = None) -> int:
+              count: int = None) -> Optional[int]:
         """Fight in a battle.
 
         Will auto activate booster and travel if allowed to do it.
@@ -1836,7 +1864,8 @@ class CitizenMilitary(CitizenTravel):
 
         return hits, err, damage
 
-    def deploy_bomb(self, battle: classes.Battle, bomb_id: int, inv_side: bool = None, count: int = 1) -> int:
+    @utils.wait_for_lock
+    def deploy_bomb(self, battle: classes.Battle, bomb_id: int, inv_side: bool = None, count: int = 1) -> Optional[int]:
         """Deploy bombs in a battle for given side.
 
         :param battle: Battle
@@ -1847,6 +1876,7 @@ class CitizenMilitary(CitizenTravel):
         :return: Deployed count
         :rtype: int
         """
+
         if not isinstance(count, int) or count < 1:
             count = 1
         has_traveled = False
@@ -2382,8 +2412,6 @@ class CitizenTasks(BaseCitizen):
 
 class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeaderBoard,
               CitizenMedia, CitizenMilitary, CitizenPolitics, CitizenSocial, CitizenTasks):
-    debug: bool = False
-
     def __init__(self, email: str = "", password: str = "", auto_login: bool = False):
         super().__init__(email, password)
         self._last_full_update = constants.min_datetime
@@ -2483,10 +2511,6 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
             for info in data.values():
                 self.reporter.report_action("NEW_MEDAL", info)
 
-    def set_debug(self, debug: bool):
-        self.debug = bool(debug)
-        self._req.debug = bool(debug)
-
     def set_pin(self, pin: str):
         self.details.pin = str(pin[:4])
 
@@ -2563,7 +2587,7 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
                 start_time = utils.good_timedelta(start_time, timedelta(minutes=30))
                 self.send_state_update()
                 self.send_inventory_update()
-                self.reporter.report_action('COMPANIES', json_val=self.my_companies.as_dict)
+                self.send_my_companies_update()
                 sleep_seconds = (start_time - self.now).total_seconds()
                 self.stop_threads.wait(sleep_seconds if sleep_seconds > 0 else 0)
         except:  # noqa
@@ -2579,6 +2603,9 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
     def send_inventory_update(self):
         self.reporter.report_action("INVENTORY", json_val=self.get_inventory(True))
 
+    def send_my_companies_update(self):
+        self.reporter.report_action('COMPANIES', json_val=self.my_companies.as_dict)
+
     def eat(self):
         """
         Try to eat food

erepublik/classes.py

@@ -719,11 +719,11 @@ class BattleSide:
 
     def __repr__(self):
         side_text = "Defender" if self.is_defender else "Invader "
-        return f"<BattleSide: {side_text} {self.country.name}|{self.points:02d}p>"
+        return f"<BattleSide: {side_text} {self.country.name}|{self.points:>2d}p>"
 
     def __str__(self):
         side_text = "Defender" if self.is_defender else "Invader "
-        return f"{side_text} {self.country.name} - {self.points:02d} points"
+        return f"{side_text} {self.country.name} - {self.points:>2d} points"
 
     def __format__(self, format_spec):
         return self.country.iso
@@ -789,7 +789,7 @@ class BattleDivision:
         return constants.TERRAINS[self.terrain]
 
     def __str__(self):
-        base_name = f"Div #{self.id} d{self.div}"
+        base_name = f"D{self.div} #{self.id}"
         if self.terrain:
             base_name += f" ({self.terrain_display})"
         if self.div_end:
@@ -899,8 +899,8 @@ class Battle:
         else:
             time_part = "-{}".format(self.start - time_now)
 
-        return (f"Battle {self.id} for {self.region_name[:16]} | "
+        return (f"Battle {self.id} for {self.region_name[:16]:16} | "
-                f"{self.invader} : {self.defender} | Round time {time_part}")
+                f"{self.invader} : {self.defender} | Round time {time_part} | {'R'+str(self.zone_id):>3}")
 
     def __repr__(self):
         return f"<Battle #{self.id} {self.invader}:{self.defender} R{self.zone_id}>"

erepublik/utils.py

@@ -152,7 +152,8 @@ def get_file(filepath: str) -> str:
 def write_file(filename: str, content: str) -> int:
     filename = get_file(filename)
     with open(filename, 'ab') as f:
-        return f.write(content.encode("utf-8"))
+        ret = f.write(content.encode("utf-8"))
+    return ret
 
 
 def write_request(response: requests.Response, is_error: bool = False):
@@ -383,3 +384,19 @@ def get_final_hit_dmg(base_dmg: Union[Decimal, float, str], rang: int,
 
 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()
+            ret = function(instance, *args, **kwargs)
+            instance.concurrency_available.set()
+            return ret
+    return wrapper

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.23.1.1
+current_version = 0.23.2.4
 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.23.1.1',
+    version='0.23.2.4',
     zip_safe=False,
 )