Bump version: 0.18.3 → 0.19.0

* inventory_updates:
  Python 3.8, isort, requirement update
  Representation of Citizen class
  Created method for current products on sale. Updated inventory to also include products on sale

# Conflicts:
#	erepublik/citizen.py

.editorconfig

@@ -19,3 +19,8 @@ insert_final_newline = false
 
 [Makefile]
 indent_style = tab
+
+[*.py]
+line_length=120
+multi_line_output=0
+balanced_wrapping=True

.gitignore

@@ -85,7 +85,7 @@ celerybeat-schedule
 
 # virtualenv
 .venv
-venv/
+venv*/
 ENV/
 
 # Spyder project settings

.travis.yml

@@ -5,7 +5,7 @@ python:
   - 3.7
   - 3.6
 
-# Command to install dependencies, e.g. pip install -r requirements.txt --use-mirrors
+# Command to install dependencies, e.g. pip install -r requirements_dev.txt --use-mirrors
 install: pip install -U tox-travis
 
 # Command to run tests, e.g. python setup.py test

CONTRIBUTING.rst

@@ -23,12 +23,6 @@ If you are reporting a bug, please include:
 * Any details about your local setup that might be helpful in troubleshooting.
 * Detailed steps to reproduce the bug.
 
-Fix Bugs
-~~~~~~~~
-
-Look through the GitHub issues for bugs. Anything tagged with "bug" and "help
-wanted" is open to whoever wants to implement it.
-
 Implement Features
 ~~~~~~~~~~~~~~~~~~
 
@@ -59,7 +53,7 @@ Get Started!
 
 Ready to contribute? Here's how to set up `erepublik` for local development.
 
-1. Fork the `erepublik_script` repo on GitHub.
+1. Fork the `erepublik` repo on GitHub.
 2. Clone your fork locally::
 
     $ git clone git@github.com:your_name_here/erepublik.git
@@ -103,7 +97,7 @@ Before you submit a pull request, check that it meets these guidelines:
    your new functionality into a function with a docstring, and add the
    feature to the list in README.rst.
 3. The pull request should work for Python 3.7.1. Check
-   https://travis-ci.org/eeriks/erepublik_script/pull_requests
+   https://travis-ci.org/eeriks/erepublik/pull_requests
    and make sure that the tests pass for all supported Python versions.
 
 Tips
@@ -112,7 +106,7 @@ Tips
 To run a subset of tests::
 
 
-    $ python -m unittest tests.test_erepublik_script
+    $ python -m unittest tests.test_erepublik
 
 Deploying
 ---------

HISTORY.rst

@@ -2,6 +2,20 @@
 History
 =======
 
+0.19.0 (2020-01-13)
+-------------------
+* Created method for current products on sale.
+* Updated inventory to also include products on sale
+* set_default_weapon() - eRepublik should return list with all available weapon qualities, but when a battle is just launched, they return only dict with barehands
+* fight() - no longer calls self.set_default_weapon()
+* find_battle_and_fight() - now calls self.set_default_weapon() just before fighting
+* update_war_info() - returns previous battle list if responses 'last_updated' isn't more than 30s old
+* get_battle_for_war(war_id) - returns Battle instance for specific war, if battle is active for given war
+* Citizen.get_raw_surplus() fixed and moved to Citizen.my_companies.get_wam_raw_usage()
+* Implemented division switching
+* improved multi bomb deploy with auto traveling,
+* Citizen.fight() simplified battle data gathering logic -> Citizen.shoot logic improved
+
 
 0.17.0 (2019-11-21)
 -------------------

Makefile

@@ -43,6 +43,8 @@ clean-pyc: ## remove Python file artifacts
 	find . -name '*.pyo' -exec rm -f {} +
 	find . -name '*~' -exec rm -f {} +
 	find . -name '__pycache__' -exec rm -fr {} +
+	rm -rf debug/
+	rm -rf log/
 
 clean-test: ## remove test and coverage artifacts
 	rm -fr .tox/

erepublik/__init__.py

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

erepublik/citizen.py

@@ -1,20 +1,21 @@
+import json
 import re
 import sys
-import warnings
 from collections import defaultdict
 from datetime import datetime, timedelta
 from itertools import product
-from json import loads, dumps
+from json import dumps, loads
 from threading import Event
 from time import sleep
-from typing import Dict, List, Tuple, Any, Union, Set
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
 
-from requests import Response, RequestException
+from requests import RequestException, Response
 
-from erepublik.classes import (CitizenAPI, Battle, Reporter, Config, Energy, Details, Politics, MyCompanies,
-                               TelegramBot, ErepublikException, BattleDivision, MyJSONEncoder)
+from erepublik.classes import (Battle, BattleDivision, CitizenAPI, Config,
+                               Details, Energy, ErepublikException,
+                               MyCompanies, MyJSONEncoder, Politics, Reporter,
+                               TelegramBot)
 from erepublik.utils import *
-from erepublik.utils import process_warning
 
 
 class Citizen(CitizenAPI):
@@ -112,6 +113,9 @@ class Citizen(CitizenAPI):
     def __str__(self) -> str:
         return f"Citizen {self.name}"
 
+    def __repr__(self):
+        return self.__str__()
+
     def __dict__(self):
         ret = super().__dict__.copy()
         ret.pop('stop_threads', None)
@@ -178,7 +182,7 @@ class Citizen(CitizenAPI):
             if j['error'] and j["message"] == 'Too many requests':
                 self.write_log("Made too many requests! Sleeping for 30 seconds.")
                 self.sleep(30)
-        except:
+        except (json.JSONDecodeError, KeyError, TypeError):
             pass
         if response.status_code >= 400:
             self.r = response
@@ -505,7 +509,21 @@ class Citizen(CitizenAPI):
             if kind not in final_items:
                 final_items[kind] = {}
 
-            icon = item['icon'] if item['icon'] else "//www.erepublik.net/images/modules/manager/tab_storage.png"
+            if item['icon']:
+                icon = item['icon']
+            else:
+                if item['type'] == 'damageBoosters':
+                    icon = "/images/modules/pvp/damage_boosters/damage_booster.png"
+                elif item['type'] == 'aircraftDamageBoosters':
+                    icon = "/images/modules/pvp/damage_boosters/air_damage_booster.png"
+                elif item['type'] == 'prestigePointsBoosters':
+                    icon = "/images/modules/pvp/prestige_points_boosters/prestige_booster.png"
+                elif item['type'] == 'speedBoosters':
+                    icon = "/images/modules/pvp/speed_boosters/speed_booster.png"
+                elif item['type'] == 'catchupBoosters':
+                    icon = "/images/modules/pvp/ghost_boosters/icon_booster_30_60.png"
+                else:
+                    icon = "//www.erepublik.net/images/modules/manager/tab_storage.png"
             data = dict(kind=kind, quality=item.get('quality', 0), amount=item.get('amount', 0),
                         durability=item.get('duration', 0), icon=icon, name=name)
             if item.get('type') in ('damageBoosters', "aircraftDamageBoosters"):
@@ -533,9 +551,22 @@ class Citizen(CitizenAPI):
                          icon=icon)
                 )
 
+        offers = {}
+        for offer in self._get_economy_my_market_offers().json():
+            kind = self.get_industry_name(offer['industryId'])
+            data = dict(quality=offer.get('quality', 0), amount=offer.get('amount', 0), icon=offer.get('icon'),
+                        kind=kind, name=kind)
+            data = {data['quality']: data}
+
+            if kind not in offers:
+                offers[kind] = {}
+
+            offers[kind].update(data)
+
         self.inventory.update({"used": j.get("inventoryStatus").get("usedStorage"),
                                "total": j.get("inventoryStatus").get("totalStorage")})
-        inventory = dict(items=dict(active=active_items, final=final_items, raw=raw_materials), status=self.inventory)
+        inventory = dict(items=dict(active=active_items, final=final_items,
+                                    raw=raw_materials, offers=offers), status=self.inventory)
         self.food["total"] = sum([self.food[q] * FOOD_ENERGY[q] for q in FOOD_ENERGY])
         return inventory
 
@@ -559,10 +590,13 @@ class Citizen(CitizenAPI):
         if not self.details.current_country:
             self.update_citizen_info()
 
-        resp_json = self._get_military_campaigns_json_list().json()
+        if self.__last_war_update_data and self.__last_war_update_data.get('last_updated', 0) + 30 > self.now.timestamp():
+            resp_json = self.__last_war_update_data
+        else:
+            resp_json = self._get_military_campaigns_json_list().json()
         if resp_json.get("countries"):
             if self.all_battles is None:
-                self.all_battles = defaultdict(Battle)
+                self.all_battles = {}
             else:
                 self.all_battles.clear()
 
@@ -638,7 +672,7 @@ class Citizen(CitizenAPI):
     def now(self) -> datetime:
         """
         Returns aware datetime object localized to US/Pacific (eRepublik time)
-        :return: datetime.datetime
+        :return: datetime
         """
         return now()
 
@@ -811,6 +845,7 @@ class Citizen(CitizenAPI):
 
                     if not self.travel_to_battle(battle_id, country_ids_to_travel):
                         break
+                self.set_default_weapon(battle_id)
                 self.fight(battle_id, side_id)
                 self.travel_to_residence()
                 self.collect_weekly_reward()
@@ -819,8 +854,7 @@ class Citizen(CitizenAPI):
     def fight(self, battle_id: int, side_id: int = None, count: int = None) -> int:
         """Fight in a battle.
 
-        Will auto activate booster and travel if allowed to do it and
-        in the beginning will switch to default weapon (air - bare hands, ground - q7, if count > 30, else bare hands.
+        Will auto activate booster and travel if allowed to do it.
         :param battle_id: int BattleId - battle to fight in
         :param side_id: int or None. Battle side to fight in, If side_id not == invader id or not in invader deployed allies list, then defender's side is chosen
         :param count: How many hits to do, if not specified self.should_fight() is called.
@@ -829,12 +863,12 @@ class Citizen(CitizenAPI):
         if not isinstance(battle_id, int):
             self.report_error(f"WARNINNG! Parameter battle_id should be 'int', but it is '{type(battle_id).__name__}'")
             battle_id = int(battle_id)
-
-        battle = self.all_battles[battle_id]
+        if battle_id not in self.all_battles:
+            self.update_war_info()
+        battle = self.all_battles.get(battle_id)
         zone_id = battle.div[11 if battle.is_air else self.division].battle_zone_id
         if not battle.is_air and self.config.boosters:
             self.activate_dmg_booster()
-        self.set_default_weapon(battle_id)
         error_count = 0
         ok_to_fight = True
         if count is None:
@@ -861,7 +895,7 @@ class Citizen(CitizenAPI):
         return error_count
 
     def _shoot(self, battle_id: int, inv_side: bool, zone_id: int):
-        battle = self.all_battles[battle_id]
+        battle = self.all_battles.get(battle_id)
         side_id = battle.invader.id if inv_side else battle.defender.id
         if battle.is_air:
             response = self._post_military_fight_air(battle_id, side_id, zone_id)
@@ -913,7 +947,7 @@ class Citizen(CitizenAPI):
         if not isinstance(count, int) or count < 1:
             count = 1
         has_traveled = False
-        battle = self.all_battles[battle_id]
+        battle = self.all_battles.get(battle_id)
         if inv_side:
             good_countries = [battle.invader.id] + battle.invader.deployed
             if self.details.current_country not in good_countries:
@@ -945,7 +979,7 @@ class Citizen(CitizenAPI):
         :param division_to: int target division to switch to
         :return:
         """
-        battle = self.all_battles[battle_id]
+        battle = self.all_battles.get(battle_id)
         self._post_main_battlefield_change_division(battle_id, battle.div[division_to].battle_zone_id)
 
     def work_ot(self):
@@ -1667,6 +1701,14 @@ class Citizen(CitizenAPI):
                 "\n".join(["{}: {}".format(k, v) for k, v in kinds.items()]), kind
             ))
 
+    def get_my_market_offers(self) -> List[Dict[str, Union[int, float, str]]]:
+        ret = []
+        for offer in self._get_economy_my_market_offers().json():
+            line = offer.copy()
+            line.pop('icon', None)
+            ret.append(line)
+        return ret
+
     def post_market_offer(self, industry: int, quality: int, amount: int, price: float) -> Response:
         if industry not in self.available_industries.values():
             self.write_log(f"Trying to sell unsupported industry {industry}")
@@ -1744,7 +1786,8 @@ class Citizen(CitizenAPI):
     @property
     def factories(self) -> Dict[int, str]:
         """Returns factory industries as dict(id: name)
-        :return: dict
+        :return: Factory id:name dict
+        ":rtype: Dict[int, str]
         """
         return {1: "Food", 2: "Weapons", 4: "House", 23: "Aircraft",
                 7: "FRM q1", 8: "FRM q2", 9: "FRM q3", 10: "FRM q4", 11: "FRM q5",
@@ -1753,13 +1796,25 @@ class Citizen(CitizenAPI):
                 24: "ARM q1", 25: "ARM q2", 26: "ARM q3", 27: "ARM q4", 28: "ARM q5", }
 
     def get_industry_id(self, industry_name: str) -> int:
-        """
-        Returns industry id
+        """Returns industry id
+
         :type industry_name: str
         :return: int
         """
         return self.available_industries.get(industry_name, 0)
 
+    def get_industry_name(self, industry_id: int) -> str:
+        """Returns industry name from industry ID
+
+        :type industry_id: int
+        :return: industry name
+        :rtype: str
+        """
+        for iname, iid in self.available_industries.items():
+            if iid == industry_id:
+                return iname
+        return ""
+
     def buy_tg_contract(self) -> Response:
         ret = self._post_main_buy_gold_items('gold', "TrainingContract2", 1)
         self.reporter.report_action("BUY_TG_CONTRACT", ret.json())
@@ -2045,7 +2100,7 @@ class Citizen(CitizenAPI):
 
     def report_error(self, msg: str = "", is_warning: bool = False):
         if is_warning:
-            process_warning(msg, self.name, sys.exc_info(), self, self.commit_id, None)
+            process_warning(msg, self.name, sys.exc_info(), self, self.commit_id)
         else:
             process_error(msg, self.name, sys.exc_info(), self, self.commit_id, None)
 
@@ -2135,8 +2190,10 @@ class Citizen(CitizenAPI):
         return self._get_military_show_weapons(battle_id).json()
 
     def set_default_weapon(self, battle_id: int) -> int:
-        battle = self.all_battles[battle_id]
+        battle = self.all_battles.get(battle_id)
         available_weapons = self._get_military_show_weapons(battle_id).json()
+        while not isinstance(available_weapons, list):
+            available_weapons = self._get_military_show_weapons(battle_id).json()
         weapon_quality = -1
         if not battle.is_air:
             for weapon in available_weapons:
@@ -2146,7 +2203,12 @@ class Citizen(CitizenAPI):
         return self.change_weapon(battle_id, weapon_quality)
 
     def change_weapon(self, battle_id: int, weapon_quality: int) -> int:
-        battle = self.all_battles[battle_id]
+        battle = self.all_battles.get(battle_id)
         battle_zone = battle.div[11 if battle.is_air else self.division].battle_zone_id
         r = self._post_military_change_weapon(battle_id, battle_zone, weapon_quality)
         return r.json().get('weaponInfluence')
+
+    def get_battle_for_war(self, war_id: int) -> Optional[Battle]:
+        self.update_war_info()
+        war_info = self.get_war_status(war_id)
+        return self.all_battles.get(war_info.get("battle_id"), None)

erepublik/classes.py

@@ -4,9 +4,9 @@ import hashlib
 import random
 import threading
 import time
-from collections import deque
-from json import JSONDecodeError, loads, JSONEncoder
-from typing import Any, Dict, List, Union, Mapping, Iterable, Tuple
+from collections import defaultdict, deque
+from json import JSONDecodeError, JSONEncoder, loads
+from typing import Any, Dict, Iterable, List, Mapping, Tuple, Union
 
 from requests import Response, Session, post
 
@@ -200,19 +200,19 @@ class SlowRequests(Session):
     timeout = datetime.timedelta(milliseconds=500)
     uas = [
         # Chrome
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.80 Safari/537.36',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',
         'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.80 Safari/537.36',
         # FireFox
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:70.0) Gecko/20100101 Firefox/70.0',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0',
         'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:70.0) Gecko/20100101 Firefox/70.0',
         'Mozilla/5.0 (X11; Linux x86_64; rv:69.0) Gecko/20100101 Firefox/69.0',
         'Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:67.0) Gecko/20100101 Firefox/67.0',
     ]
     debug = False
 
@@ -567,10 +567,6 @@ Class for unifying eRepublik known endpoints and their required/optional paramet
     def _get_military_campaigns_json_list(self) -> Response:
         return self.get("{}/military/campaignsJson/list".format(self.url))
 
-    def _get_military_show_weapons(self, battle_id: int) -> Response:
-        params = {"_token": self.token, "battleId": battle_id}
-        return self.get("{}/military/show-weapons".format(self.url), params=params)
-
     def _get_military_unit_data(self, unit_id: int, **kwargs) -> Response:
         params = {"groupId": unit_id, "panel": "members", **kwargs}
         return self.get("{}/military/military-unit-data/".format(self.url), params=params)
@@ -1099,17 +1095,25 @@ class BattleDivision:
     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]
-    ):
-        self.battle_zone_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]}
+    def __init__(self, **kwargs):
+        """Battle division helper class
+
+        :param kwargs: must contain keys:
+            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]
+        """
+
+        self.battle_zone_id = kwargs.get("div_id", 0)
+        self.end = kwargs.get("end", 0)
+        self.epic = kwargs.get("epic", 0)
+        self.dom_pts = dict({"inv": kwargs.get("inv_pts", 0), "def": kwargs.get("def_pts", 0)})
+        self.wall = dict({"for": kwargs.get("wall_for", 0), "dom": kwargs.get("wall_dom", 0)})
+        self.def_medal = {"id": kwargs.get("def_medal", 0)[0], "dmg": kwargs.get("def_medal", 0)[1]}
+        self.inv_medal = {"id": kwargs.get("inv_medal", 0)[0], "dmg": kwargs.get("inv_medal", 0)[1]}
+
+    @property
+    def id(self):
+        return self.battle_zone_id
 
 
 class Battle:
@@ -1164,7 +1168,7 @@ class Battle:
                 [row.get('id') for row in battle.get('def', {}).get('ally_list') if row['deployed']]
             )
 
-        self.div = {}
+        self.div = defaultdict(BattleDivision)
         for div, data in battle.get('div', {}).items():
             div = int(data.get('div'))
             if data.get('end'):

erepublik/utils.py

@@ -8,7 +8,7 @@ import time
 import traceback
 import unicodedata
 from pathlib import Path
-from typing import Union, Any, List, NoReturn, Mapping, Optional
+from typing import Any, List, Mapping, NoReturn, Optional, Union
 
 import pytz
 import requests
@@ -19,6 +19,10 @@ __all__ = ["FOOD_ENERGY", "COMMIT_ID", "COUNTRIES", "erep_tz", 'COUNTRY_LINK',
            "write_silent_log", "write_interactive_log", "get_file", "write_file",
            "send_email", "normalize_html_json", "process_error", "process_warning", 'report_promo', 'calculate_hit']
 
+if not sys.version_info >= (3, 7):
+    raise AssertionError('This script requires Python version 3.7 and higher\n'
+                         'But Your version is v{}.{}.{}'.format(*sys.version_info))
+
 FOOD_ENERGY = dict(q1=2, q2=4, q3=6, q4=8, q5=10, q6=12, q7=20)
 COMMIT_ID = "7b92e19"
 
@@ -113,6 +117,15 @@ def localize_dt(dt: Union[datetime.date, datetime.datetime]) -> datetime.datetim
 
 
 def good_timedelta(dt: datetime.datetime, td: datetime.timedelta) -> datetime.datetime:
+    """Normalize timezone aware datetime object after timedelta to correct jumps over DST switches
+
+    :param dt: Timezone aware datetime object
+    :type dt: datetime.datetime
+    :param td: timedelta object
+    :type td: datetime.timedelta
+    :return: datetime object with correct timezone when jumped over DST
+    :rtype: datetime.datetime
+    """
     return erep_tz.normalize(dt + td)
 
 
@@ -292,11 +305,17 @@ def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commi
     """
     Process error logging and email sending to developer
     :param interactive: Should print interactively
+    :type interactive: bool
     :param log_info: String to be written in output
+    :type log_info: str
     :param name: String Instance name
+    :type name: str
     :param exc_info: tuple output from sys.exc_info()
+    :type exc_info: tuple
     :param citizen: Citizen instance
+    :type citizen: Citizen
     :param commit_id: Code's version by commit id
+    :type commit_id: str
     """
     type_, value_, traceback_ = exc_info
     content = [log_info]

examples/battle_launcher.py

@@ -0,0 +1,96 @@
+import threading
+from datetime import timedelta
+
+from erepublik import Citizen, utils
+
+CONFIG = {
+    'email': 'player@email.com',
+    'password': 'Pa$5w0rd!',
+    'interactive': True,
+    'fight': True,
+    'debug': True,
+    'start_battles': {
+        121672: {"auto_attack": False, "regions": [661]},
+        125530: {"auto_attack": False, "regions": [259]},
+        125226: {"auto_attack": True, "regions": [549]},
+        124559: {"auto_attack": True, "regions": [176]}
+    }
+}
+
+
+def _battle_launcher(player: Citizen):
+    """Launch battles. Check every 5th minute (0,5,10...45,50,55) if any battle could be started on specified regions
+    and after launching wait for 90 minutes before starting next attack so that all battles aren't launched at the same
+    time. If player is allowed to fight, do 100 hits on the first round in players division.
+
+    :param player: Logged in Citizen instance
+    ":type player: Citizen
+    """
+    global CONFIG
+    finished_war_ids = {*[]}
+    war_data = CONFIG.get('start_battles', {})
+    war_ids = {int(war_id) for war_id in war_data.keys()}
+    next_attack_time = player.now
+    next_attack_time = next_attack_time.replace(minute=next_attack_time.minute // 5 * 5, second=0)
+    while not player.stop_threads.is_set():
+        try:
+            attacked = False
+            player.update_war_info()
+            running_wars = {b.war_id for b in player.all_battles.values()}
+            for war_id in war_ids - finished_war_ids - running_wars:
+                war = war_data[str(war_id)]
+                war_regions = set(war.get('regions'))
+                auto_attack = war.get('auto_attack')
+
+                status = player.get_war_status(war_id)
+                if status.get('ended', False):
+                    CONFIG['start_battles'].pop(str(war_id), None)
+                    finished_war_ids.add(war_id)
+                    continue
+                elif not status.get('can_attack'):
+                    continue
+
+                if auto_attack or (player.now.hour > 20 or player.now.hour < 2):
+                    for reg in war_regions:
+                        if attacked:
+                            break
+                        if reg in status.get('regions', {}).keys():
+                            player.launch_attack(war_id, reg, status.get('regions', {}).get(reg))
+                            attacked = True
+                            hits = 100
+                            if player.energy.food_fights >= hits and player.config.fight:
+                                for _ in range(120):
+                                    player.update_war_info()
+                                    battle_id = player.get_war_status(war_id).get("battle_id")
+                                    if battle_id is not None and battle_id in player.all_battles:
+                                        player.fight(battle_id, player.details.citizenship, hits)
+                                        break
+                                    player.sleep(1)
+                        if attacked:
+                            break
+                if attacked:
+                    break
+            war_ids -= finished_war_ids
+            if attacked:
+                next_attack_time = utils.good_timedelta(next_attack_time, timedelta(hours=1, minutes=30))
+            else:
+                next_attack_time = utils.good_timedelta(next_attack_time, timedelta(minutes=5))
+            player.stop_threads.wait(utils.get_sleep_seconds(next_attack_time))
+        except:
+            player.report_error("Task error: start_battles")
+
+
+def main():
+    player = Citizen(email=CONFIG['email'], password=CONFIG['password'], auto_login=False)
+    player.config.interactive = CONFIG['interactive']
+    player.config.fight = CONFIG['fight']
+    player.set_debug(CONFIG.get('debug', False))
+    player.login()
+    if CONFIG.get('start_battles'):
+        name = "{}-start_battles-{}".format(player.name, threading.active_count() - 1)
+        state_thread = threading.Thread(target=_battle_launcher, args=(player,), name=name)
+        state_thread.start()
+
+
+if __name__ == "__main__":
+    main()

examples/eat_work_train.py

@@ -0,0 +1,102 @@
+from datetime import timedelta
+
+from erepublik import Citizen, utils
+
+CONFIG = {
+    'email': 'player@email.com',
+    'password': 'Pa$5w0rd!',
+    'interactive': True,
+    'debug': True
+}
+
+
+def main():
+    player = Citizen(email=CONFIG['email'], password=CONFIG['password'], auto_login=False)
+    player.config.interactive = CONFIG['interactive']
+    player.config.fight = CONFIG['fight']
+    player.set_debug(CONFIG.get('debug', False))
+    player.login()
+    now = player.now.replace(second=0, microsecond=0)
+    dt_max = now.replace(year=9999)
+    tasks = {
+        'eat': now,
+    }
+    if player.config.work:
+        tasks.update({'work': now})
+    if player.config.train:
+        tasks.update({'train': now})
+    if player.config.ot:
+        tasks.update({'ot': now})
+    if player.config.wam:
+        tasks.update({'wam': now.replace(hour=14, minute=0)})
+    while True:
+        player.update_all()
+        if tasks.get('work', dt_max) <= now:
+            player.write_log("Doing task: work")
+            player.update_citizen_info()
+            player.work()
+            if player.config.ot:
+                tasks['ot'] = now
+            player.collect_daily_task()
+            next_time = utils.good_timedelta(now.replace(hour=0, minute=0, second=0), timedelta(days=1))
+            tasks.update({'work': next_time})
+
+        if tasks.get('train', dt_max) <= now:
+            player.write_log("Doing task: train")
+            player.update_citizen_info()
+            player.train()
+            player.collect_daily_task()
+            next_time = utils.good_timedelta(now.replace(hour=0, minute=0, second=0), timedelta(days=1))
+            tasks.update({'train': next_time})
+
+        if tasks.get('wam', dt_max) <= now:
+            player.write_log("Doing task: Work as manager")
+            success = player.work_wam()
+            player.eat()
+            if success:
+                next_time = utils.good_timedelta(now.replace(hour=14, minute=0, second=0, microsecond=0),
+                                                 timedelta(days=1))
+            else:
+                next_time = utils.good_timedelta(now.replace(second=0, microsecond=0), timedelta(minutes=30))
+
+            tasks.update({'wam': next_time})
+
+        if tasks.get('eat', dt_max) <= now:
+            player.write_log("Doing task: eat")
+            player.eat()
+
+            if player.energy.food_fights > player.energy.limit // 10:
+                next_minutes = 12
+            else:
+                next_minutes = (player.energy.limit - 5 * player.energy.interval) // player.energy.interval * 6
+
+            next_time = player.energy.reference_time + timedelta(minutes=next_minutes)
+            tasks.update({'eat': next_time})
+
+        if tasks.get('ot', dt_max) <= now:
+            player.write_log("Doing task: ot")
+            if now > player.my_companies.next_ot_time:
+                player.work_ot()
+                next_time = now + timedelta(minutes=60)
+            else:
+                next_time = player.my_companies.next_ot_time
+            tasks.update({'ot': next_time})
+
+        closest_next_time = dt_max
+        next_tasks = []
+        for task, next_time in sorted(tasks.items(), key=lambda s: s[1]):
+            next_tasks.append("{}: {}".format(next_time.strftime('%F %T'), task))
+            if next_time < closest_next_time:
+                closest_next_time = next_time
+        sleep_seconds = int(utils.get_sleep_seconds(closest_next_time))
+        if sleep_seconds <= 0:
+            player.write_log(f"Loop detected! Offending task: '{next_tasks[0]}'")
+        player.write_log("My next Tasks and there time:\n" + "\n".join(sorted(next_tasks)))
+        player.write_log("Sleeping until (eRep): {} (sleeping for {}s)".format(
+            closest_next_time.strftime("%F %T"), sleep_seconds))
+        seconds_to_sleep = sleep_seconds if sleep_seconds > 0 else 0
+        player.sleep(seconds_to_sleep)
+
+
+if __name__ == "__main__":
+    main()

requirements_dev.txt

@@ -1,14 +1,16 @@
-pip==19.1.1
 bumpversion==0.5.3
-wheel==0.33.4
-watchdog==0.9.0
-flake8==3.7.8
-tox==3.13.2
-coverage==4.5.3
-Sphinx==2.2.0
-twine==2.0.0
-ipython
-PyInstaller
-pytz==2019.1
+coverage==5.0.2
+edx-sphinx-theme==1.5.0
+flake8==3.7.9
+ipython==7.11.1
+isort==4.3.21
+pip==19.3.1
+PyInstaller==3.5
+pytz==2019.3
 requests==2.22.0
-edx-sphinx-theme
+setuptools==44.0.0
+Sphinx==2.3.1
+tox==3.14.3
+twine==3.1.1
+watchdog==0.9.0
+wheel==0.33.6

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.18.2
+current_version = 0.19.0
 commit = True
 tag = True
 

setup.py

@@ -11,7 +11,7 @@ with open('README.rst') as readme_file:
 with open('HISTORY.rst') as history_file:
     history = history_file.read()
 
-requirements = ['pytz>=2019.2', 'requests>=2.22']
+requirements = ['pytz==2019.3', 'requests==2.22.0']
 
 setup_requirements = []
 
@@ -27,6 +27,7 @@ setup(
         'Natural Language :: English',
         'Programming Language :: Python :: 3',
         'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
     ],
     description="Python package for automated eRepublik playing",
     entry_points={},
@@ -42,6 +43,6 @@ setup(
     test_suite='tests',
     tests_require=test_requirements,
     url='https://github.com/eeriks/erepublik/',
-    version='0.18.2',
+    version='0.19.0',
     zip_safe=False,
 )