Bump version: 0.20.3.2 → 0.20.3.3

erepublik/__init__.py

@@ -4,8 +4,8 @@
 
 __author__ = """Eriks Karls"""
 __email__ = 'eriks@72.lv'
-__version__ = '0.20.1.7'
-__commit_id__ = "d1e078e"
+__version__ = '0.20.3.3'
+__commit_id__ = "cd861ea"
 
 from erepublik import classes, utils
 from erepublik.citizen import Citizen

erepublik/access_points.py

@@ -450,6 +450,9 @@ class ErepublikPoliticsAPI(CitizenBaseAPI):
         data = dict(_token=self.token, presentation=presentation)
         return self.post("{}/candidate-for-congress".format(self.url), data=data)
 
+    def _get_presidential_elections(self, country_id: int, timestamp: int) -> Response:
+        return self.get(f"{self.url}/main/presidential-elections/{country_id}/{timestamp}")
+
 
 class ErepublikPresidentAPI(CitizenBaseAPI):
     def _post_wars_attack_region(self, war_id: int, region_id: int, region_name: str) -> Response:
@@ -565,6 +568,10 @@ class ErepublikProfileAPI(CitizenBaseAPI):
         data = dict(_token=self.token, rewardId=reward_id)
         return self.post("{}/main/weekly-challenge-collect-reward".format(self.url), data=data)
 
+    def _post_main_profile_update(self, action: str, params: str):
+        data = {"action": action, "params": params, "_token": self.token}
+        return self.post(f"{self.url}/main/profile-update", data=data)
+
 
 class ErepublikTravelAPI(CitizenBaseAPI):
     def _post_main_travel(self, check: str, **kwargs) -> Response:

erepublik/classes.py

@@ -16,6 +16,44 @@ INDUSTRIES = {1: "Food", 2: "Weapons", 4: "House", 23: "Aircraft",
               24: "ARM q1", 25: "ARM q2", 26: "ARM q3", 27: "ARM q4", 28: "ARM q5", }
 
 
+class Country:
+    id: int
+    name: str
+    link: str
+    iso: str
+
+    def __init__(self, country_id: int, name: str, link: str, iso: str):
+        self.id = country_id
+        self.name = name
+        self.link = link
+        self.iso = iso
+
+    def __repr__(self):
+        return f"Country({self.id}, '{self.name}', '{self.link}', '{self.iso}')"
+
+    def __str__(self):
+        return f"#{self.id} {self.name}"
+
+    def __format__(self, format_spec):
+        return self.iso
+
+    def __int__(self):
+        return self.id
+
+    def __eq__(self, other):
+        if isinstance(other, (int, float)):
+            return self.id == int(other)
+        else:
+            try:
+                return self.id == int(other)
+            except ValueError:
+                return self == other
+
+    @property
+    def __dict__(self):
+        return dict(id=self.id, name=self.name, iso=self.iso)
+
+
 class ErepublikException(Exception):
     def __init__(self, message):
         super().__init__(message)
@@ -32,7 +70,8 @@ class Holding:
     region: int
     companies: List["Company"]
 
-    def __init__(self, _id: int, region: int):
+    def __init__(self, _id: int, region: int, citizen):
+        self.citizen = citizen
         self.id: int = _id
         self.region: int = region
         self.companies: List["Company"] = list()
@@ -63,6 +102,24 @@ class Holding:
                 wrm += company.raw_usage
         return dict(frm=frm, wrm=wrm)
 
+    def get_wam_companies(self, raw_factory: bool = None):
+        raw = []
+        factory = []
+        for company in self.wam_companies:
+            if not company.already_worked and not company.cannot_wam_reason == "war":
+                if company.is_raw:
+                    raw.append(company)
+                else:
+                    factory.append(company)
+        if raw_factory is not None and not raw_factory:
+            return factory
+        elif raw_factory is not None and raw_factory:
+            return raw
+        elif raw_factory is None:
+            return raw + factory
+        else:
+            raise ErepublikException("raw_factory should be True/False/None")
+
     def __str__(self):
         name = f"Holding (#{self.id}) with {len(self.companies)} "
         if len(self.companies) % 10 == 1:
@@ -187,6 +244,15 @@ class Company:
                     can_wam=self.can_wam, cannot_wam_reason=self.cannot_wam_reason, industry=self.industry,
                     already_worked=self.already_worked, preset_works=self.preset_works)
 
+    def dissolve(self) -> Response:
+        self.holding.citizen.write_log(f"{self} dissolved!")
+        # noinspection PyProtectedMember
+        return self.holding.citizen._post_economy_sell_company(self.id, self.holding.citizen.details.pin, sell=False)
+
+    def upgrade(self, level: int) -> Response:
+        # noinspection PyProtectedMember
+        return self.holding.citizen._post_economy_upgrade_company(self.id, level, self.holding.citizen.details.pin)
+
 
 class MyCompanies:
     work_units: int = 0
@@ -196,7 +262,9 @@ class MyCompanies:
     holdings: Dict[int, Holding]
     companies: List[Company]
 
-    def __init__(self):
+    def __init__(self, citizen):
+        from erepublik import Citizen
+        self.citizen: Citizen = citizen
         self.holdings: Dict[int, Holding] = dict()
         self.companies: List[Company] = list()
         self.next_ot_time = utils.now()
@@ -207,9 +275,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.holdings.update(
+                    {int(holding.get('id')): Holding(holding['id'], holding['region_id'], self.citizen)})
         if not self.holdings.get(0):
-            self.holdings.update({0: Holding(0, 0)})  # unassigned
+            self.holdings.update({0: Holding(0, 0, self.citizen)})  # unassigned
 
     def prepare_companies(self, companies: Dict[str, Dict[str, Any]]):
         """
@@ -240,43 +309,8 @@ class MyCompanies:
     def get_total_wam_count(self) -> int:
         return sum([holding.wam_count for holding in self.holdings.values()])
 
-    def get_holding_wam_count(self, holding_id: int, raw_factory=None) -> int:
-        """
-        Returns amount of wam enabled companies in the holding
-        :param holding_id: holding id
-        :param raw_factory: True - only raw, False - only factories, None - both
-        :return: int
-        """
-        return len(self.get_holding_wam_companies(holding_id, raw_factory))
-
-    def get_holding_wam_companies(self, holding_id: int, raw_factory: bool = None) -> List[Company]:
-        """
-        Returns WAM enabled companies in the holding, True - only raw, False - only factories, None - both
-        :param holding_id: holding id
-        :param raw_factory: bool or None
-        :return: list
-        """
-        raw = []
-        factory = []
-        if holding_id in self.holdings:
-            for company in self.holdings[holding_id].wam_companies:
-                if not company.already_worked and not company.cannot_wam_reason == "war":
-                    if company.is_raw:
-                        raw.append(company)
-                    else:
-                        factory.append(company)
-        if raw_factory is not None and not raw_factory:
-            return factory
-        elif raw_factory is not None and raw_factory:
-            return raw
-        elif raw_factory is None:
-            return raw + factory
-        else:
-            raise ErepublikException("raw_factory should be True/False/None")
-
     @staticmethod
     def get_needed_inventory_usage(companies: Union[Company, List[Company]]) -> Decimal:
-
         if isinstance(companies, list):
             return sum([company.products_made * 100 if company.is_raw else 1 for company in companies])
         else:
@@ -428,11 +462,11 @@ class Details:
     gold = 0
     next_pp: List[int] = None
     citizen_id = 0
-    citizenship = 0
+    citizenship: Country
     current_region = 0
-    current_country = 0
+    current_country: Country
     residence_region = 0
-    residence_country = 0
+    residence_country: 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, }
@@ -493,28 +527,35 @@ class House:
 
 class Reporter:
     __to_update: List[Dict[Any, Any]] = None
-    name: str = ""
-    email: str = ""
-    citizen_id: int = 0
     key: str = ""
     allowed: bool = False
 
+    @property
+    def name(self) -> str:
+        return self.citizen.name
+
+    @property
+    def email(self) -> str:
+        return self.citizen.config.email
+
+    @property
+    def citizen_id(self) -> int:
+        return self.citizen.details.citizen_id
+
     @property
     def __dict__(self):
         return dict(name=self.name, email=self.email, citizen_id=self.citizen_id, key=self.key, allowed=self.allowed,
                     queue=self.__to_update)
 
-    def __init__(self):
+    def __init__(self, citizen):
+        self.citizen = citizen
         self._req = Session()
         self.url = "https://api.erep.lv"
         self._req.headers.update({"user-agent": "Bot reporter v2"})
         self.__to_update = []
         self.__registered: bool = False
 
-    def do_init(self, name: str = "", email: str = "", citizen_id: int = 0):
-        self.name: str = name
-        self.email: str = email
-        self.citizen_id: int = citizen_id
+    def do_init(self):
         self.key: str = ""
         self.__update_key()
         self.register_account()
@@ -573,10 +614,11 @@ class Reporter:
     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))
 
-    def fetch_battle_priorities(self, country_id: int) -> List[int]:
+    def fetch_battle_priorities(self, country: Country) -> List["Battle"]:
         try:
-            battle_response = self._req.get(f'{self.url}/api/v1/battles/{country_id}')
-            return battle_response.json().get('battle_ids', [])
+            battle_response = self._req.get(f'{self.url}/api/v1/battles/{country.id}')
+            return [self.citizen.all_battles[bid] for bid in battle_response.json().get('battle_ids', []) if
+                    bid in self.citizen.all_battles]
         except:  # noqa
             return []
 
@@ -617,57 +659,102 @@ class MyJSONEncoder(json.JSONEncoder):
 
 
 class BattleSide:
-    id: int
     points: int
-    deployed: List[int] = None
-    allies: List[int] = None
+    deployed: List[Country]
+    allies: List[Country]
+    battle: "Battle"
+    country: Country
+    defender: bool
 
-    def __init__(self, country_id: int, points: int, allies: List[int], deployed: List[int]):
-        self.id = country_id
+    def __init__(self, battle: "Battle", country: Country, points: int, allies: List[Country], deployed: List[Country],
+                 defender: bool):
+        self.battle = battle
+        self.country = country
         self.points = points
-        self.allies = [int(ally) for ally in allies]
-        self.deployed = [int(ally) for ally in deployed]
+        self.allies = allies
+        self.deployed = deployed
+        self.defender = defender
+
+    @property
+    def id(self) -> int:
+        return self.country.id
+
+    def __repr__(self):
+        side_text = "Defender" if self.defender else "Invader "
+        return f"<BattleSide: {side_text} {self.country.name}|{self.points:02d}p>"
+
+    def __str__(self):
+        side_text = "Defender" if self.defender else "Invader "
+        return f"{side_text} {self.country.name} - {self.points:02d} points"
+
+    def __format__(self, format_spec):
+        return self.country.iso
+
+    @property
+    def __dict__(self):
+        return dict(points=self.points, country=self.country, defender=self.defender, allies=self.allies,
+                    deployed=self.deployed, battle=repr(self.battle))
 
 
 class BattleDivision:
+    id: int
     end: datetime.datetime
     epic: bool
     dom_pts: Dict[str, int]
     wall: Dict[str, Union[int, float]]
-    battle_zone_id: int
     def_medal: Dict[str, int]
     inv_medal: Dict[str, int]
+    terrain: int
+    div: int
+    battle: "Battle"
+
+    @property
+    def __dict__(self):
+        return dict(id=self.id, division=self.div, terrain=(self.terrain, self.terrain_display), wall=self.wall,
+                    dom_pts=self.dom_pts, epic=self.epic, battle=str(self.battle), end=self.div_end)
+
+    @property
+    def is_air(self):
+        return self.div == 11
 
     @property
     def div_end(self) -> bool:
         return utils.now() >= self.end
 
-    def __init__(self, div_id: int, end: datetime.datetime, epic: bool, inv_pts: int, def_pts: int,
-                 wall_for: int, wall_dom: float, def_medal: Tuple[int, int], inv_medal: Tuple[int, int]):
+    def __init__(self, battle: "Battle", div_id: int, end: datetime.datetime, epic: bool, div: int, wall_for: int,
+                 wall_dom: float, terrain_id: int = 0):
         """Battle division helper class
 
         :type div_id: int
         :type end: datetime.datetime
         :type epic: bool
-        :type inv_pts: int
-        :type def_pts: int
+        :type div: int
+        :type terrain_id: int
         :type wall_for: int
         :type wall_dom: float
-        :type def_medal: Tuple[int, int]
-        :type inv_medal: Tuple[int, int]
         """
-
-        self.battle_zone_id = div_id
+        self.battle = battle
+        self.id = div_id
         self.end = end
         self.epic = epic
-        self.dom_pts = dict({"inv": inv_pts, "def": def_pts})
         self.wall = dict({"for": wall_for, "dom": wall_dom})
-        self.def_medal = {"id": def_medal[0], "dmg": def_medal[1]}
-        self.inv_medal = {"id": inv_medal[0], "dmg": inv_medal[1]}
+        self.terrain = terrain_id
+        self.div = div
 
     @property
-    def id(self):
-        return self.battle_zone_id
+    def terrain_display(self):
+        return _TERRAINS[self.terrain]
+
+    def __str__(self):
+        base_name = f"Div #{self.id} d{self.div}"
+        if self.terrain:
+            base_name += f" ({self.terrain_display})"
+        if self.div_end:
+            base_name += " Ended"
+        return base_name
+
+    def __repr__(self):
+        return f"<BattleDivision #{self.id} (battle #{self.battle.id})>"
 
 
 class Battle:
@@ -680,11 +767,33 @@ class Battle:
     invader: BattleSide
     defender: BattleSide
     div: Dict[int, BattleDivision]
+    region_id: int
+    region_name: str
 
     @property
-    def is_air(self) -> bool:
+    def __dict__(self):
+        return dict(id=self.id, war_id=self.war_id, divisions=self.div, zone=self.zone_id, rw=self.is_rw,
+                    dict_lib=self.is_dict_lib, start=self.start, sides={'inv': self.invader, 'def': self.defender},
+                    region=[self.region_id, self.region_name])
+
+    @property
+    def has_air(self) -> bool:
+        for div in self.div.values():
+            if div.div == 11:
+                return True
         return not bool(self.zone_id % 4)
 
+    @property
+    def has_ground(self) -> bool:
+        for div in self.div.values():
+            if div.div != 11:
+                return True
+        return bool(self.zone_id % 4)
+
+    @property
+    def link(self):
+        return f"https://www.erepublik.com/en/military/battlefield/{self.id}"
+
     def __init__(self, battle: Dict[str, Any]):
         """Object representing eRepublik battle.
 
@@ -696,45 +805,39 @@ class Battle:
         self.zone_id = int(battle.get('zone_id'))
         self.is_rw = bool(battle.get('is_rw'))
         self.is_as = bool(battle.get('is_as'))
-        self.is_dict_lib = bool(battle.get('is_dict')) or bool(battle.get('is_lib'))
+        self.region_id = battle.get('region', {}).get('id')
+        self.region_name = battle.get('region', {}).get('name')
         self.start = datetime.datetime.fromtimestamp(int(battle.get('start', 0)), tz=utils.erep_tz)
 
         self.invader = BattleSide(
-            battle.get('inv', {}).get('id'), battle.get('inv', {}).get('points'),
-            [row.get('id') for row in battle.get('inv', {}).get('ally_list')],
-            [row.get('id') for row in battle.get('inv', {}).get('ally_list') if row['deployed']]
+            self, COUNTRIES[battle.get('inv', {}).get('id')], battle.get('inv', {}).get('points'),
+            [COUNTRIES[row.get('id')] for row in battle.get('inv', {}).get('ally_list')],
+            [COUNTRIES[row.get('id')] for row in battle.get('inv', {}).get('ally_list') if row['deployed']], False
         )
 
         self.defender = BattleSide(
-            battle.get('def', {}).get('id'), battle.get('def', {}).get('points'),
-            [row.get('id') for row in battle.get('def', {}).get('ally_list')],
-            [row.get('id') for row in battle.get('def', {}).get('ally_list') if row['deployed']]
+            self, COUNTRIES[battle.get('def', {}).get('id')], battle.get('def', {}).get('points'),
+            [COUNTRIES[row.get('id')] for row in battle.get('def', {}).get('ally_list')],
+            [COUNTRIES[row.get('id')] for row in battle.get('def', {}).get('ally_list') if row['deployed']], True
         )
 
         self.div = {}
         for div, data in battle.get('div', {}).items():
-            div = int(data.get('div'))
+            div = int(div)
             if data.get('end'):
                 end = datetime.datetime.fromtimestamp(data.get('end'), tz=utils.erep_tz)
             else:
                 end = utils.localize_dt(datetime.datetime.max - datetime.timedelta(days=1))
 
-            if not data.get('stats',{}).get('def'):
-                def_medal = (0, 0)
-            else:
-                def_medal = (data['stats']['def']['citizenId'], data['stats']['def']['damage'])
-            if not data.get('stats').get('inv'):
-                inv_medal = (0, 0)
-            else:
-                inv_medal = (data['stats']['inv']['citizenId'], data['stats']['inv']['damage'])
-            battle_div = BattleDivision(div_id=data.get('id'), end=end, epic=data.get('epic_type') in [1, 5],
-                                        inv_pts=data.get('dom_pts').get("inv"), def_pts=data.get('dom_pts').get("def"),
-                                        wall_for=data.get('wall').get("for"), wall_dom=data.get('wall').get("dom"),
-                                        def_medal=def_medal, inv_medal=inv_medal)
+            battle_div = BattleDivision(self, div_id=data.get('id'), div=data.get('div'), end=end,
+                                        epic=data.get('epic_type') in [1, 5],
+                                        wall_for=data.get('wall').get("for"),
+                                        wall_dom=data.get('wall').get("dom"),
+                                        terrain_id=data.get('terrain', 0))
 
             self.div.update({div: battle_div})
 
-    def __repr__(self):
+    def __str__(self):
         now = utils.now()
         is_started = self.start < utils.now()
         if is_started:
@@ -742,10 +845,10 @@ class Battle:
         else:
             time_part = "-{}".format(self.start - now)
 
-        return f"Battle {self.id} | " \
-               f"{utils.ISO_CC[self.invader.id]} : {utils.ISO_CC[self.defender.id]} | " \
-               f"Round {self.zone_id:2} | " \
-               f"Round time {time_part}"
+        return f"Battle {self.id} for {self.region_name[:16]} | {self.invader} : {self.defender} | Round time {time_part}"
+
+    def __repr__(self):
+        return f"<Battle #{self.id} {self.invader}:{self.defender} R{self.zone_id}>"
 
 
 class EnergyToFight:
@@ -830,22 +933,6 @@ class TelegramBot:
 
         return True
 
-    def report_free_bhs(self, battles: List[Tuple[int, int, int, int, datetime.timedelta]]):
-        battle_links = []
-        for battle_id, side_id, against_id, damage, time_left in battles:
-            total_seconds = int(time_left.total_seconds())
-            time_start = ""
-            hours, remainder = divmod(total_seconds, 3600)
-            if hours:
-                time_start = f"{hours}h "
-            minutes, seconds = divmod(remainder, 60)
-            time_start += f"{minutes:02}m {seconds:02}s"
-            damage = "{:,}".format(damage).replace(',', ' ')
-            battle_links.append(f"*{damage}*dmg bh for [{utils.COUNTRIES[side_id]} vs {utils.COUNTRIES[against_id]}]"
-                                f"(https://www.erepublik.com/en/military/battlefield/{battle_id}) "
-                                f"_time since start {time_start}_")
-        self.send_message("Free BHs:\n" + "\n".join(battle_links))
-
     def report_full_energy(self, available: int, limit: int, interval: int):
         if (utils.now() - self._last_full_energy_report).total_seconds() >= 30 * 60:
             self._last_full_energy_report = utils.now()
@@ -875,7 +962,54 @@ class TelegramBot:
 
 class OfferItem(NamedTuple):
     price: float = 99_999.
-    country: int = 0
+    country: Country = Country(0, "", "", "")
     amount: int = 0
     offer_id: int = 0
     citizen_id: int = 0
+
+
+COUNTRIES: Dict[int, Country] = {
+    1: Country(1, 'Romania', 'Romania', 'ROU'), 9: Country(9, 'Brazil', 'Brazil', 'BRA'),
+    10: Country(10, 'Italy', 'Italy', 'ITA'), 11: Country(11, 'France', 'France', 'FRA'),
+    12: Country(12, 'Germany', 'Germany', 'DEU'), 13: Country(13, 'Hungary', 'Hungary', 'HUN'),
+    14: Country(14, 'China', 'China', 'CHN'), 15: Country(15, 'Spain', 'Spain', 'ESP'),
+    23: Country(23, 'Canada', 'Canada', 'CAN'), 24: Country(24, 'USA', 'USA', 'USA'),
+    26: Country(26, 'Mexico', 'Mexico', 'MEX'), 27: Country(27, 'Argentina', 'Argentina', 'ARG'),
+    28: Country(28, 'Venezuela', 'Venezuela', 'VEN'), 29: Country(29, 'United Kingdom', 'United-Kingdom', 'GBR'),
+    30: Country(30, 'Switzerland', 'Switzerland', 'CHE'), 31: Country(31, 'Netherlands', 'Netherlands', 'NLD'),
+    32: Country(32, 'Belgium', 'Belgium', 'BEL'), 33: Country(33, 'Austria', 'Austria', 'AUT'),
+    34: Country(34, 'Czech Republic', 'Czech-Republic', 'CZE'), 35: Country(35, 'Poland', 'Poland', 'POL'),
+    36: Country(36, 'Slovakia', 'Slovakia', 'SVK'), 37: Country(37, 'Norway', 'Norway', 'NOR'),
+    38: Country(38, 'Sweden', 'Sweden', 'SWE'), 39: Country(39, 'Finland', 'Finland', 'FIN'),
+    40: Country(40, 'Ukraine', 'Ukraine', 'UKR'), 41: Country(41, 'Russia', 'Russia', 'RUS'),
+    42: Country(42, 'Bulgaria', 'Bulgaria', 'BGR'), 43: Country(43, 'Turkey', 'Turkey', 'TUR'),
+    44: Country(44, 'Greece', 'Greece', 'GRC'), 45: Country(45, 'Japan', 'Japan', 'JPN'),
+    47: Country(47, 'South Korea', 'South-Korea', 'KOR'), 48: Country(48, 'India', 'India', 'IND'),
+    49: Country(49, 'Indonesia', 'Indonesia', 'IDN'), 50: Country(50, 'Australia', 'Australia', 'AUS'),
+    51: Country(51, 'South Africa', 'South Africa', 'ZAF'),
+    52: Country(52, 'Republic of Moldova', 'Republic-of-Moldova', 'MDA'),
+    53: Country(53, 'Portugal', 'Portugal', 'PRT'), 54: Country(54, 'Ireland', 'Ireland', 'IRL'),
+    55: Country(55, 'Denmark', 'Denmark', 'DNK'), 56: Country(56, 'Iran', 'Iran', 'IRN'),
+    57: Country(57, 'Pakistan', 'Pakistan', 'PAK'), 58: Country(58, 'Israel', 'Israel', 'ISR'),
+    59: Country(59, 'Thailand', 'Thailand', 'THA'), 61: Country(61, 'Slovenia', 'Slovenia', 'SVN'),
+    63: Country(63, 'Croatia', 'Croatia', 'HRV'), 64: Country(64, 'Chile', 'Chile', 'CHL'),
+    65: Country(65, 'Serbia', 'Serbia', 'SRB'), 66: Country(66, 'Malaysia', 'Malaysia', 'MYS'),
+    67: Country(67, 'Philippines', 'Philippines', 'PHL'), 68: Country(68, 'Singapore', 'Singapore', 'SGP'),
+    69: Country(69, 'Bosnia and Herzegovina', 'Bosnia-Herzegovina', 'BiH'),
+    70: Country(70, 'Estonia', 'Estonia', 'EST'), 80: Country(80, 'Montenegro', 'Montenegro', 'MNE'),
+    71: Country(71, 'Latvia', 'Latvia', 'LVA'), 72: Country(72, 'Lithuania', 'Lithuania', 'LTU'),
+    73: Country(73, 'North Korea', 'North-Korea', 'PRK'), 74: Country(74, 'Uruguay', 'Uruguay', 'URY'),
+    75: Country(75, 'Paraguay', 'Paraguay', 'PRY'), 76: Country(76, 'Bolivia', 'Bolivia', 'BOL'),
+    77: Country(77, 'Peru', 'Peru', 'PER'), 78: Country(78, 'Colombia', 'Colombia', 'COL'),
+    79: Country(79, 'Republic of Macedonia (FYROM)', 'Republic-of-Macedonia-FYROM', 'MKD'),
+    81: Country(81, 'Republic of China (Taiwan)', 'Republic-of-China-Taiwan', 'TWN'),
+    82: Country(82, 'Cyprus', 'Cyprus', 'CYP'), 167: Country(167, 'Albania', 'Albania', 'ALB'),
+    83: Country(83, 'Belarus', 'Belarus', 'BLR'), 84: Country(84, 'New Zealand', 'New-Zealand', 'NZL'),
+    164: Country(164, 'Saudi Arabia', 'Saudi-Arabia', 'SAU'), 165: Country(165, 'Egypt', 'Egypt', 'EGY'),
+    166: Country(166, 'United Arab Emirates', 'United-Arab-Emirates', 'UAE'),
+    168: Country(168, 'Georgia', 'Georgia', 'GEO'), 169: Country(169, 'Armenia', 'Armenia', 'ARM'),
+    170: Country(170, 'Nigeria', 'Nigeria', 'NGA'), 171: Country(171, 'Cuba', 'Cuba', 'CUB')
+}
+
+_TERRAINS = {0: "Standard", 1: 'Industrial', 2: 'Urban', 3: 'Suburbs', 4: 'Airport', 5: 'Plains', 6: 'Wasteland',
+             7: 'Mountains', 8: 'Beach', 9: 'Swamp', 10: 'Mud', 11: 'Hills', 12: 'Jungle', 13: 'Forest', 14: 'Desert'}

erepublik/utils.py

@@ -21,7 +21,7 @@ try:
 except ImportError:
     import json
 
-__all__ = ["FOOD_ENERGY", "COMMIT_ID", "COUNTRIES", "erep_tz", 'COUNTRY_LINK',
+__all__ = ["FOOD_ENERGY", "COMMIT_ID", "erep_tz",
            "now", "localize_dt", "localize_timestamp", "good_timedelta", "eday_from_date", "date_from_eday",
            "get_sleep_seconds", "interactive_sleep", "silent_sleep",
            "write_silent_log", "write_interactive_log", "get_file", "write_file",
@@ -95,45 +95,6 @@ GROUND_RANK_POINTS: Dict[int, int] = {
     86: 180000000000, 87: 190000000000, 88: 200000000000, 89: 210000000000
 }
 
-COUNTRIES: Dict[int, str] = {
-    1: 'Romania', 9: 'Brazil', 10: 'Italy', 11: 'France', 12: 'Germany', 13: 'Hungary', 14: 'China', 15: 'Spain',
-    23: 'Canada', 24: 'USA', 26: 'Mexico', 27: 'Argentina', 28: 'Venezuela', 29: 'United Kingdom', 30: 'Switzerland',
-    31: 'Netherlands', 32: 'Belgium', 33: 'Austria', 34: 'Czech Republic', 35: 'Poland', 36: 'Slovakia', 37: 'Norway',
-    38: 'Sweden', 39: 'Finland', 40: 'Ukraine', 41: 'Russia', 42: 'Bulgaria', 43: 'Turkey', 44: 'Greece', 45: 'Japan',
-    47: 'South Korea', 48: 'India', 49: 'Indonesia', 50: 'Australia', 51: 'South Africa', 52: 'Republic of Moldova',
-    53: 'Portugal', 54: 'Ireland', 55: 'Denmark', 56: 'Iran', 57: 'Pakistan', 58: 'Israel', 59: 'Thailand',
-    61: 'Slovenia', 63: 'Croatia', 64: 'Chile', 65: 'Serbia', 66: 'Malaysia', 67: 'Philippines', 68: 'Singapore',
-    69: 'Bosnia and Herzegovina', 70: 'Estonia', 71: 'Latvia', 72: 'Lithuania', 73: 'North Korea', 74: 'Uruguay',
-    75: 'Paraguay', 76: 'Bolivia', 77: 'Peru', 78: 'Colombia', 79: 'Republic of Macedonia (FYROM)', 80: 'Montenegro',
-    81: 'Republic of China (Taiwan)', 82: 'Cyprus', 83: 'Belarus', 84: 'New Zealand', 164: 'Saudi Arabia', 165: 'Egypt',
-    166: 'United Arab Emirates', 167: 'Albania', 168: 'Georgia', 169: 'Armenia', 170: 'Nigeria', 171: 'Cuba'
-}
-
-COUNTRY_LINK: Dict[int, str] = {
-    1: 'Romania', 9: 'Brazil', 11: 'France', 12: 'Germany', 13: 'Hungary', 82: 'Cyprus', 168: 'Georgia', 15: 'Spain',
-    23: 'Canada', 26: 'Mexico', 27: 'Argentina', 28: 'Venezuela', 80: 'Montenegro', 24: 'USA', 29: 'United-Kingdom',
-    50: 'Australia', 47: 'South-Korea', 171: 'Cuba', 79: 'Republic-of-Macedonia-FYROM', 30: 'Switzerland', 165: 'Egypt',
-    31: 'Netherlands', 32: 'Belgium', 33: 'Austria', 34: 'Czech-Republic', 35: 'Poland', 36: 'Slovakia', 37: 'Norway',
-    38: 'Sweden', 39: 'Finland', 40: 'Ukraine', 41: 'Russia', 42: 'Bulgaria', 43: 'Turkey', 44: 'Greece', 45: 'Japan',
-    48: 'India', 49: 'Indonesia', 78: 'Colombia', 68: 'Singapore', 51: 'South Africa', 52: 'Republic-of-Moldova',
-    53: 'Portugal', 54: 'Ireland', 55: 'Denmark', 56: 'Iran', 57: 'Pakistan', 58: 'Israel', 59: 'Thailand', 10: 'Italy',
-    61: 'Slovenia', 63: 'Croatia', 64: 'Chile', 65: 'Serbia', 66: 'Malaysia', 67: 'Philippines', 70: 'Estonia',
-    77: 'Peru', 71: 'Latvia', 72: 'Lithuania', 73: 'North-Korea', 74: 'Uruguay', 75: 'Paraguay', 76: 'Bolivia',
-    81: 'Republic-of-China-Taiwan', 166: 'United-Arab-Emirates', 167: 'Albania', 69: 'Bosnia-Herzegovina', 14: 'China',
-    169: 'Armenia', 83: 'Belarus', 84: 'New-Zealand', 164: 'Saudi-Arabia', 170: 'Nigeria'
-}
-
-ISO_CC: Dict[int, str] = {
-    1: 'ROU', 9: 'BRA', 10: 'ITA', 11: 'FRA', 12: 'DEU', 13: 'HUN', 14: 'CHN', 15: 'ESP', 23: 'CAN', 24: 'USA',
-    26: 'MEX', 27: 'ARG', 28: 'VEN', 29: 'GBR', 30: 'CHE', 31: 'NLD', 32: 'BEL', 33: 'AUT', 34: 'CZE', 35: 'POL',
-    36: 'SVK', 37: 'NOR', 38: 'SWE', 39: 'FIN', 40: 'UKR', 41: 'RUS', 42: 'BGR', 43: 'TUR', 44: 'GRC', 45: 'JPN',
-    47: 'KOR', 48: 'IND', 49: 'IDN', 50: 'AUS', 51: 'ZAF', 52: 'MDA', 53: 'PRT', 54: 'IRL', 55: 'DNK', 56: 'IRN',
-    57: 'PAK', 58: 'ISR', 59: 'THA', 61: 'SVN', 63: 'HRV', 64: 'CHL', 65: 'SRB', 66: 'MYS', 67: 'PHL', 68: 'SGP',
-    69: 'BiH', 70: 'EST', 71: 'LVA', 72: 'LTU', 73: 'PRK', 74: 'URY', 75: 'PRY', 76: 'BOL', 77: 'PER', 78: 'COL',
-    79: 'MKD', 80: 'MNE', 81: 'TWN', 82: 'CYP', 83: 'BLR', 84: 'NZL', 164: 'SAU', 165: 'EGY', 166: 'UAE', 167: 'ALB',
-    168: 'GEO', 169: 'ARM', 170: 'NGA', 171: 'CUB',
-}
-
 
 def now() -> datetime.datetime:
     return datetime.datetime.now(erep_tz).replace(microsecond=0)

setup.cfg

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