Bump version: 0.23.2.5 → 0.23.2.6

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'
+__version__ = '0.23.2.6'
 
 from erepublik import classes, utils, constants
 from erepublik.citizen import Citizen

erepublik/access_points.py

@@ -29,14 +29,10 @@ class SlowRequests(Session):
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:82.0) Gecko/20100101 Firefox/82.0',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:81.0) Gecko/20100101 Firefox/81.0',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:80.0) Gecko/20100101 Firefox/80.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:79.0) Gecko/20100101 Firefox/79.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Firefox/78.0',
         'Mozilla/5.0 (X11; Linux x86_64; rv:83.0) Gecko/20100101 Firefox/83.0',
         'Mozilla/5.0 (X11; Linux x86_64; rv:82.0) Gecko/20100101 Firefox/82.0',
         'Mozilla/5.0 (X11; Linux x86_64; rv:81.0) Gecko/20100101 Firefox/81.0',
         'Mozilla/5.0 (X11; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0',
-        '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: bool = False
 
@@ -87,9 +83,9 @@ 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)
             with open(self.request_log_name, 'ab') as file:
                 file.write(body.encode("UTF-8"))
+            pass
 
     def _log_response(self, url, resp, redirect: bool = False):
         from erepublik import Citizen
@@ -113,8 +109,8 @@ class SlowRequests(Session):
                 file_data.update({"ext": "html"})
 
             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'))
+            utils.write_file(filename, resp.text)
+        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,7 @@ class CitizenEconomy(CitizenTravel):
             ret.update({house_quality: till})
         return ret
 
-    def buy_and_activate_house(self, q: int) -> Dict[int, datetime]:
+    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()
@@ -1031,12 +1040,14 @@ class CitizenEconomy(CitizenTravel):
             global_cheapest = self.get_market_offers("House", q)[f"q{q}"]
             if global_cheapest.price + 200 < local_cheapest.price:
                 if self.travel_to_country(global_cheapest.country):
-                    buy = self.buy_from_market(global_cheapest.offer_id, 1)
+                    buy = self.buy_market_offer(global_cheapest, 1)
                 else:
                     buy = {'error': True, 'message': 'Unable to travel!'}
             else:
-                buy = self.buy_from_market(local_cheapest.offer_id, 1)
-            if buy["error"]:
+                buy = self.buy_market_offer(local_cheapest, 1)
+            if buy is None:
+                pass
+            elif buy["error"]:
                 msg = f"Unable to buy q{q} house! \n{buy['message']}"
                 self.write_log(msg)
             else:
@@ -1058,7 +1069,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 +1191,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 +1687,60 @@ 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
+                    maverick_ok = self.maverick and self.config.maverick
+                    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 maverick_ok):
+                        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):
-                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
+            for battle, division, side in self.find_battle_to_fight():
+
                 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 +1756,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)
-                    self.fight(battle, battle_zone, side)
+
+                if self.change_division(battle, division):
+                    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 +1866,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 +1878,7 @@ class CitizenMilitary(CitizenTravel):
         :return: Deployed count
         :rtype: int
         """
+
         if not isinstance(count, int) or count < 1:
             count = 1
         has_traveled = False
@@ -2382,8 +2414,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 +2513,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 +2589,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 +2605,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]} | "
-                f"{self.invader} : {self.defender} | Round time {time_part}")
+        return (f"Battle {self.id} for {self.region_name[:16]:16} | "
+                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}>"
@@ -1016,7 +1016,7 @@ class TelegramBot:
 
 
 class OfferItem(NamedTuple):
-    price: float = 99_999.
+    price: float = 999_999_999.
     country: constants.Country = constants.Country(0, "", "", "")
     amount: int = 0
     offer_id: int = 0

erepublik/utils.py

@@ -25,7 +25,7 @@ __all__ = ['VERSION', 'calculate_hit', 'caught_error', 'date_from_eday', 'eday_f
            'get_air_hit_dmg_value', 'get_file', 'get_ground_hit_dmg_value', 'get_sleep_seconds', 'good_timedelta',
            'interactive_sleep', 'json', 'localize_dt', 'localize_timestamp', 'normalize_html_json', 'now',
            'process_error', 'process_warning', 'send_email', 'silent_sleep', 'slugify', 'write_file',
-           'write_interactive_log', 'write_silent_log']
+           'write_interactive_log', 'write_silent_log', 'get_final_hit_dmg', 'wait_for_lock']
 
 if not sys.version_info >= (3, 6):
     raise AssertionError('This script requires Python version 3.6 and higher\n'
@@ -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):
@@ -338,17 +339,8 @@ def calculate_hit(strength: float, rang: int, tp: bool, elite: bool, ne: bool, b
     base_wpn = (1 + Decimal(str(weapon / 100)))
     dmg = 10 * base_str * base_rnk * base_wpn
 
-    if elite:
-        dmg = dmg * 11 / 10
-
-    if tp and rang >= 70:
-        dmg = dmg * (1 + Decimal((rang - 69) / 10))
-
-    dmg = dmg * (100 + booster) / 100
-
-    if ne:
-        dmg = dmg * 11 / 10
-    return round(dmg, dec)
+    dmg = get_final_hit_dmg(dmg, rang, tp=tp, elite=elite, ne=ne, booster=booster)
+    return Decimal(round(dmg, dec))
 
 
 def get_ground_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_patriot: bool = False,
@@ -371,6 +363,19 @@ def get_air_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_pat
     return calculate_hit(0, rang, true_patriot, elite, natural_enemy, booster, weapon_power)
 
 
+def get_final_hit_dmg(base_dmg: Union[Decimal, float, str], rang: int,
+                      tp: bool = False, elite: bool = False, ne: bool = False, booster: int = 0) -> Decimal:
+    dmg = Decimal(str(base_dmg))
+
+    if elite:
+        dmg = dmg * 11 / 10
+    if tp and rang >= 70:
+        dmg = dmg * (1 + Decimal((rang - 69) / 10))
+    dmg = dmg * (100 + booster) / 100
+    if ne:
+        dmg = dmg * 11 / 10
+    return Decimal(dmg)
+
 # def _clear_up_battle_memory(battle):
 #     del battle.invader._battle, battle.defender._battle
 #     for div_id, division in battle.div.items():
@@ -379,3 +384,19 @@ def get_air_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_pat
 
 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
+current_version = 0.23.2.6
 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',
+    version='0.23.2.6',
     zip_safe=False,
 )