Bump version: 0.15.3 → 0.16.0

Fixed double code execution in Citizen.update_citizen_info(None) calling Citizen.update_citizen_info(html) and executing code twice.

CONTRIBUTING.rst

@@ -15,7 +15,7 @@ Types of Contributions
 Report Bugs
 ~~~~~~~~~~~
 
-Report bugs at https://github.com/eeriks/erepublik_script/issues.
+Report bugs at https://github.com/eeriks/erepublik/issues.
 
 If you are reporting a bug, please include:
 
@@ -45,7 +45,7 @@ articles, and such.
 Submit Feedback
 ~~~~~~~~~~~~~~~
 
-The best way to send feedback is to file an issue at https://github.com/eeriks/erepublik_script/issues.
+The best way to send feedback is to file an issue at https://github.com/eeriks/erepublik/issues.
 
 If you are proposing a feature:
 
@@ -62,7 +62,7 @@ Ready to contribute? Here's how to set up `erepublik` for local development.
 1. Fork the `erepublik_script` repo on GitHub.
 2. Clone your fork locally::
 
-    $ git clone git@github.com:your_name_here/erepublik_script.git
+    $ git clone git@github.com:your_name_here/erepublik.git
 
 3. Install your local copy into a virtualenv. Assuming you have virtualenvwrapper installed, this is how you set up your fork for local development::
 

HISTORY.rst

@@ -2,13 +2,30 @@
 History
 =======
 
-0.1.0 (2019-07-19)
+* Telegram notification integration
-------------------
+* Improved serialization to JSON
+* When failing to do WAM because of not enough food - buy food
+* Buy food buys 48h worth instead of 24h energy
 
-* First release on PyPI.
+0.15.3 (2019-08-24)
+-------------------
+
+* Update after eRepublik changed campaign apis
+
+
+0.15.0 (2019-07-30)
+-------------------
+
+* CitizenAPI class methods renamed to "private", they are intended to be used internally.
+* TODO: None of the Citizen class's methods should return Response object - CitizenAPI is meant for that.
 
 
 0.14.4 (2019-07-23)
 -------------------
 
-* Wall post comment endpoints updated with comment create endpoints
+* Wall post comment endpoints updated with comment create endpoints.
+
+0.1.0 (2019-07-19)
+------------------
+
+* First release on PyPI.

README.rst

@@ -15,7 +15,7 @@ Python package for automated eRepublik playing
 
 
 * Free software: MIT license
-* Documentation: https://erepublik.readthedocs.io.
+* Documentation: https://erepublik.readthedocs.io/en/latest/
 
 
 Features

config.json

@@ -33,4 +33,4 @@
  "travel_to_fight": true,
  "wam": true,
  "work": true
-}
+}

docs/conf.py

@@ -23,6 +23,7 @@ import sys
 sys.path.insert(0, os.path.abspath('..'))
 
 import erepublik
+import edx_theme
 
 # -- General configuration ---------------------------------------------
 
@@ -32,7 +33,7 @@ import erepublik
 
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode']
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode', 'edx_theme']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
@@ -84,7 +85,8 @@ todo_include_todos = False
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = 'alabaster'
+html_theme = 'edx_theme'
+html_theme_path = [edx_theme.get_html_theme_path()]
 
 # Theme options are theme-specific and customize the look and feel of a
 # theme further.  For a list of options available for each theme, see the
@@ -158,6 +160,3 @@ texinfo_documents = [
      'One line description of project.',
      'Miscellaneous'),
 ]
-
-
-

docs/installation.rst

@@ -32,13 +32,13 @@ You can either clone the public repository:
 
 .. code-block:: console
 
-    $ git clone git://github.com/eeriks/erepublik_script
+    $ git clone git://github.com/eeriks/erepublik
 
 Or download the `tarball`_:
 
 .. code-block:: console
 
-    $ curl  -OL https://github.com/eeriks/erepublik_script/tarball/master
+    $ curl  -OL https://github.com/eeriks/erepublik/tarball/master
 
 Once you have a copy of the source, you can install it with:
 
@@ -47,5 +47,5 @@ Once you have a copy of the source, you can install it with:
     $ python setup.py install
 
 
-.. _Github repo: https://github.com/eeriks/erepublik_script
+.. _Github repo: https://github.com/eeriks/erepublik
-.. _tarball: https://github.com/eeriks/erepublik_script/tarball/master
+.. _tarball: https://github.com/eeriks/erepublik/tarball/master

docs/make.bat

@@ -1,36 +1,36 @@
-@ECHO OFF
+@ECHO OFF
-
+
-pushd %~dp0
+pushd %~dp0
-
+
-REM Command file for Sphinx documentation
+REM Command file for Sphinx documentation
-
+
-if "%SPHINXBUILD%" == "" (
+if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=python -msphinx
+	set SPHINXBUILD=python -msphinx
-)
+)
-set SOURCEDIR=.
+set SOURCEDIR=.
-set BUILDDIR=_build
+set BUILDDIR=_build
-set SPHINXPROJ=erepublik_script
+set SPHINXPROJ=erepublik
-
+
-if "%1" == "" goto help
+if "%1" == "" goto help
-
+
-%SPHINXBUILD% >NUL 2>NUL
+%SPHINXBUILD% >NUL 2>NUL
-if errorlevel 9009 (
+if errorlevel 9009 (
-	echo.
+	echo.
-	echo.The Sphinx module was not found. Make sure you have Sphinx installed,
+	echo.The Sphinx module was not found. Make sure you have Sphinx installed,
-	echo.then set the SPHINXBUILD environment variable to point to the full
+	echo.then set the SPHINXBUILD environment variable to point to the full
-	echo.path of the 'sphinx-build' executable. Alternatively you may add the
+	echo.path of the 'sphinx-build' executable. Alternatively you may add the
-	echo.Sphinx directory to PATH.
+	echo.Sphinx directory to PATH.
-	echo.
+	echo.
-	echo.If you don't have Sphinx installed, grab it from
+	echo.If you don't have Sphinx installed, grab it from
-	echo.http://sphinx-doc.org/
+	echo.http://sphinx-doc.org/
-	exit /b 1
+	exit /b 1
-)
+)
-
+
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
-goto end
+goto end
-
+
-:help
+:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
-
+
-:end
+:end
-popd
+popd

docs/usage.rst

@@ -4,4 +4,7 @@ Usage
 
 To use eRepublik script in a project::
 
-    import erepublik
+    from erepublik import Citizen
+    player = Citizen('email@domain.com', 'password')
+    player.update_all()
+

erepublik/__init__.py

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

erepublik/classes.py

@@ -2,12 +2,14 @@ import datetime
 import decimal
 import hashlib
 import random
+import sys
 import time
+import traceback
 from collections import deque
 from json import JSONDecodeError, loads, JSONEncoder
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Union, Mapping, Iterable, Tuple
 
-from requests import Response, Session
+from requests import Response, Session, post
 
 from erepublik import utils
 
@@ -26,11 +28,13 @@ class ErepublikNetworkException(Exception):
 class MyCompanies:
     work_units: int = 0
     next_ot_time: datetime.datetime
-    holdings: Dict[int, Dict] = dict()
+    holdings: Dict[int, Dict] = None
-    companies: Dict[int, Dict] = dict()
+    companies: Dict[int, Dict] = None
     ff_lockdown: int = 0
 
     def __init__(self):
+        self.holdings = dict()
+        self.companies = dict()
         self.next_ot_time = utils.now()
 
     def prepare_holdings(self, holdings: dict):
@@ -41,7 +45,7 @@ class MyCompanies:
         template = dict(id=0, num_factories=0, region_id=0, companies=[])
 
         for holding_id, holding in holdings.items():
-            tmp: Dict[str, Union[List[Any], Any]] = {}
+            tmp: Dict[str, Union[Iterable[Any], Any]] = {}
             for key in template:
                 if key == 'companies':
                     tmp.update({key: []})
@@ -59,7 +63,7 @@ class MyCompanies:
                         production=0, base_production=0, wam_enabled=False, can_work_as_manager=False,
                         preset_own_work=0, already_worked=False, can_assign_employees=False, preset_works=0,
                         todays_works=0, holding_company_id=None, is_assigned_to_holding=False,
-                        cannot_work_as_manager_reason=False)
+                        cannot_work_as_manager_reason=False, industry_id=0)
 
         for c_id, company in companies.items():
             tmp = {}
@@ -117,7 +121,10 @@ class MyCompanies:
         raw = []
         factory = []
         if holding_id in self.holdings:
-            for company_id in self.holdings.get(holding_id, {}).get('companies', []):
+            for company_id in sorted(self.holdings.get(holding_id, {}).get('companies', []),
+                                     key=lambda cid: (-self.companies[cid].get('is_raw'),  # True, False
+                                                      self.companies[cid].get('industry_id'),  # F W H A
+                                                      -self.companies[cid].get('quality'),)):  # 7, 6, .. 2, 1
                 company = self.companies.get(company_id, {})
                 wam_enabled = bool(company.get('wam_enabled', {}))
                 already_worked = not company.get('already_worked', {})
@@ -154,28 +161,33 @@ class MyCompanies:
 
         raise ErepublikException("Wrong function call")
 
+    @property
+    def __dict__(self):
+        ret = {}
+        for key in dir(self):
+            if not key.startswith('_'):
+                ret[key] = getattr(self, key)
+        return ret
+
 
 class SlowRequests(Session):
     last_time: datetime.datetime
     timeout = datetime.timedelta(milliseconds=500)
     uas = [
         # Chrome
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',
-        'Chrome/73.0.3683.103 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) '
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.80 Safari/537.36',
-        'Chrome/72.0.3626.13 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 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36',
-        'Chrome/71.0.3578.98 Safari/537.36',
+        'Mozilla/5.0 (X11; Linux x86_64) 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/73.0.3683.103 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.11 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36',
         # FireFox
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:66.0) Gecko/20100101 Firefox/66.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:65.0) Gecko/20100101 Firefox/65.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:64.0) Gecko/20100101 Firefox/64.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:66.0) Gecko/20100101 Firefox/66.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:69.0) Gecko/20100101 Firefox/69.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:65.0) Gecko/20100101 Firefox/65.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:64.0) Gecko/20100101 Firefox/64.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:67.0) Gecko/20100101 Firefox/67.0',
     ]
     debug = False
 
@@ -278,38 +290,21 @@ class Config:
     force_wam = False
     sort_battles_time = True
     force_travel = False
+    telegram = True
+    telegram_chat_id = 0
+    telegram_token = ""
 
     @property
     def wt(self):
         return self.work and self.train
 
+    @property
     def __dict__(self) -> Dict[str, Union[bool, str, List[str]]]:
-        return dict(
+        ret = {}
-            email=self.email,
+        for key in dir(self):
-            password=self.password,
+            if not key.startswith('_') and key not in ['email', 'password']:
-            work=self.work,
+                ret[key] = getattr(self, key)
-            train=self.train,
+        return ret
-            wam=self.wam,
-            auto_sell=self.auto_sell,
-            auto_sell_all=self.auto_sell_all,
-            employees=self.employees,
-            fight=self.fight,
-            air=self.air,
-            ground=self.ground,
-            all_in=self.all_in,
-            next_energy=self.next_energy,
-            boosters=self.boosters,
-            travel_to_fight=self.travel_to_fight,
-            epic_hunt=self.epic_hunt,
-            epic_hunt_ebs=self.epic_hunt_ebs,
-            rw_def_side=self.rw_def_side,
-            interactive=self.interactive,
-            continuous_fighting=self.continuous_fighting,
-            auto_buy_raw=self.auto_buy_raw,
-            force_wam=self.force_wam,
-            sort_battles_time=self.sort_battles_time,
-            force_travel=self.force_travel,
-        )
 
 
 class Energy:
@@ -330,7 +325,7 @@ class Energy:
 
     @property
     def food_fights(self):
-        return (self.recoverable + self.recovered) // 10
+        return self.available // 10
 
     @property
     def reference_time(self):
@@ -342,7 +337,7 @@ class Energy:
 
     @property
     def is_recoverable_full(self):
-        return self.recoverable >= self.limit - self.interval
+        return self.recoverable >= self.limit - 5 * self.interval
 
     @property
     def is_recovered_full(self):
@@ -358,13 +353,11 @@ class Energy:
 
     @property
     def __dict__(self):
-        return dict(
+        ret = {}
-            limit=self.limit,
+        for key in dir(self):
-            interval=self.interval,
+            if not key.startswith('_'):
-            recoverable=self.recoverable,
+                ret[key] = getattr(self, key)
-            recovered=self.recovered,
+        return ret
-            reference_time=self.reference_time
-        )
 
 
 class Details(object):
@@ -410,6 +403,14 @@ class Details(object):
             next_level_up = (1 + (self.xp // 10)) * 10
         return next_level_up - self.xp
 
+    @property
+    def __dict__(self):
+        ret = {}
+        for key in dir(self):
+            if not key.startswith('_'):
+                ret[key] = getattr(self, key)
+        return ret
+
 
 class Politics:
     is_party_member: bool = False
@@ -420,6 +421,14 @@ class Politics:
     is_congressman: bool = False
     is_country_president: bool = False
 
+    @property
+    def __dict__(self):
+        ret = {}
+        for key in dir(self):
+            if not key.startswith('_'):
+                ret[key] = getattr(self, key)
+        return ret
+
 
 class House(object):
     quality = None
@@ -441,6 +450,9 @@ class CitizenAPI:
     token: str = ""
 
     def __init__(self):
+        """
+Class for unifying eRepublik known endpoints and their required/optional parameters
+        """
         self._req = SlowRequests()
 
     def post(self, url: str, *args, **kwargs) -> Response:
@@ -449,130 +461,144 @@ class CitizenAPI:
     def get(self, url: str, **kwargs) -> Response:
         return self._req.get(url, **kwargs)
 
-    def get_article_json(self, article_id: int) -> Response:
+    def _get_main_article_json(self, article_id: int) -> Response:
         return self.get("{}/main/articleJson/{}".format(self.url, article_id))
 
-    def get_battlefield_choose_side(self, battle: int, side: int) -> Response:
+    def _get_military_battlefield_choose_side(self, battle: int, side: int) -> Response:
         return self.get("{}/military/battlefield-choose-side/{}/{}".format(self.url, battle, side))
 
-    def get_candidate_party(self, party_slug: str) -> Response:
+    def _get_candidate_party(self, party_slug: str) -> Response:
         return self.post("{}/candidate/{}".format(self.url, party_slug))
 
-    def get_citizen_hovercard(self, citizen: int) -> Response:
+    def _get_main_citizen_hovercard(self, citizen: int) -> Response:
         return self.get("{}/main/citizen-hovercard/{}".format(self.url, citizen))
 
-    def get_citizen_profile(self, player_id: int):
+    def _get_main_citizen_profile_json(self, player_id: int) -> Response:
         return self.get("{}/main/citizen-profile-json/{}".format(self.url, player_id))
 
-    def get_citizen_daily_assistant(self):
+    def _get_main_citizen_daily_assistant(self) -> Response:
         return self.get("{}/main/citizenDailyAssistant".format(self.url))
 
-    def get_city_data_residents(self, city: int, page: int = 1, params: Dict[str, Any] = None):
+    def _get_main_city_data_residents(self, city: int, page: int = 1, params: Mapping[str, Any] = None) -> Response:
         if params is None:
             params = {}
         return self.get("{}/main/city-data/{}/residents".format(self.url, city), params={"currentPage": page, **params})
 
-    def get_country_military(self, country: str) -> Response:
+    def _get_country_military(self, country: str) -> Response:
         return self.get("{}/country/military/{}".format(self.url, country))
 
-    def get_economy_inventory_items(self) -> Response:
+    def _get_economy_citizen_accounts(self, organisation_id: int) -> Response:
+        return self.get("{}/economy/citizen-accounts/{}".format(self.url, organisation_id))
+
+    def _get_economy_inventory_items(self) -> Response:
         return self.get("{}/economy/inventory-items/".format(self.url))
 
-    def get_economy_job_market_json(self, country: int) -> Response:
+    def _get_economy_job_market_json(self, country: int) -> Response:
         return self.get("{}/economy/job-market-json/{}/1/desc".format(self.url, country))
 
-    def get_economy_my_companies(self) -> Response:
+    def _get_economy_my_companies(self) -> Response:
         return self.get("{}/economy/myCompanies".format(self.url))
 
-    def get_economy_my_market_offers(self) -> Response:
+    def _get_economy_my_market_offers(self) -> Response:
         return self.get("{}/economy/myMarketOffers".format(self.url))
 
-    def get_job_data(self) -> Response:
+    def _get_main_job_data(self) -> Response:
         return self.get("{}/main/job-data".format(self.url))
 
-    def get_leaderboards_damage_aircraft_rankings(self, country: int, weeks: int = 0, mu: int = 0) -> Response:
+    def _get_main_leaderboards_damage_aircraft_rankings(self, country: int, weeks: int = 0, mu: int = 0) -> Response:
         data = (country, weeks, mu)
         return self.get("{}/main/leaderboards-damage-aircraft-rankings/{}/{}/{}/0".format(self.url, *data))
 
-    def get_leaderboards_damage_rankings(self, country: int, weeks: int = 0, mu: int = 0, div: int = 0) -> Response:
+    def _get_main_leaderboards_damage_rankings(self, country: int, weeks: int = 0, mu: int = 0,
+                                               div: int = 0) -> Response:
         data = (country, weeks, mu, div)
         return self.get("{}/main/leaderboards-damage-rankings/{}/{}/{}/{}".format(self.url, *data))
 
-    def get_leaderboards_kills_aircraft_rankings(self, country: int, weeks: int = 0, mu: int = 0) -> Response:
+    def _get_main_leaderboards_kills_aircraft_rankings(self, country: int, weeks: int = 0, mu: int = 0) -> Response:
         data = (country, weeks, mu)
         return self.get("{}/main/leaderboards-kills-aircraft-rankings/{}/{}/{}/0".format(self.url, *data))
 
-    def get_leaderboards_kills_rankings(self, country: int, weeks: int = 0, mu: int = 0, div: int = 0) -> Response:
+    def _get_main_leaderboards_kills_rankings(self, country: int, weeks: int = 0, mu: int = 0,
+                                              div: int = 0) -> Response:
         data = (country, weeks, mu, div)
         return self.get("{}/main/leaderboards-kills-rankings/{}/{}/{}/{}".format(self.url, *data))
 
-    def get_main(self):
+    def _get_main(self) -> Response:
         return self.get(self.url)
 
-    def get_message_alerts(self, page: int = 1) -> Response:
+    def _get_main_messages_paginated(self, page: int = 1) -> Response:
-        return self.get_message_alerts(page)
+        return self.get("{}/main/messages-paginated/{}".format(self.url, page))
 
-    def get_military_campaigns(self) -> Response:
+    def _get_military_campaigns(self) -> Response:
         return self.get("{}/military/campaigns-new/".format(self.url))
 
-    def get_military_unit_data(self, unit_id: int, **kwargs) -> Response:
+    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)
 
-    def get_money_donation_accept(self, donation_id: int) -> Response:
+    def _get_main_money_donation_accept(self, donation_id: int) -> Response:
         return self.get("{}/main/money-donation/accept/{}".format(self.url, donation_id), params={"_token": self.token})
 
-    def get_money_donation_reject(self, donation_id: int) -> Response:
+    def _get_main_money_donation_reject(self, donation_id: int) -> Response:
         return self.get("{}/main/money-donation/reject/{}".format(self.url, donation_id), params={"_token": self.token})
 
-    def get_party_members(self, party: int) -> Response:
+    def _get_main_notifications_ajax_community(self, page: int = 1) -> Response:
+        return self.get("{}/main/notificationsAjax/community/{}".format(self.url, page))
+
+    def _get_main_notifications_ajax_system(self, page: int = 1) -> Response:
+        return self.get("{}/main/notificationsAjax/system/{}".format(self.url, page))
+
+    def _get_main_notifications_ajax_report(self, page: int = 1) -> Response:
+        return self.get("{}/main/notificationsAjax/report/{}".format(self.url, page))
+
+    def _get_main_party_members(self, party: int) -> Response:
         return self.get("{}/main/party-members/{}".format(self.url, party))
 
-    def get_rankings_parties(self, country: int) -> Response:
+    def _get_main_rankings_parties(self, country: int) -> Response:
         return self.get("{}/main/rankings-parties/1/{}".format(self.url, country))
 
-    def get_training_grounds_json(self) -> Response:
+    def _get_main_training_grounds_json(self) -> Response:
         return self.get("{}/main/training-grounds-json".format(self.url))
 
-    def get_weekly_challenge_data(self) -> Response:
+    def _get_main_weekly_challenge_data(self) -> Response:
         return self.get("{}/main/weekly-challenge-data".format(self.url))
 
-    def post_activate_battle_effect(self, battle: int, kind: str, citizen_id: int) -> Response:
+    def _get_wars_show(self, war_id: int) -> Response:
+        return self.get("{}/wars/show/{}".format(self.url, war_id))
+
+    def _post_main_activate_battle_effect(self, battle: int, kind: str, citizen_id: int) -> Response:
         data = dict(battleId=battle, citizenId=citizen_id, type=kind, _token=self.token)
         return self.post("{}/main/fight-activateBattleEffect".format(self.url), data=data)
 
-    def post_article_comments(self, article: int, page: int = 1) -> Response:
+    def _post_main_article_comments(self, article: int, page: int = 1) -> Response:
         data = dict(_token=self.token, articleId=article, page=page)
         if page:
             data.update({'page': page})
         return self.post("{}/main/articleComments".format(self.url), data=data)
 
-    def post_article_comments_create(self, message: str, article: int, parent: int = 0) -> Response:
+    def _post_main_article_comments_create(self, message: str, article: int, parent: int = 0) -> Response:
         data = dict(_token=self.token, message=message, articleId=article)
         if parent:
             data.update({"parentId": parent})
         return self.post("{}/main/articleComments/create".format(self.url), data=data)
 
-    def post_battle_console(self, battle: int, zone: int, round_id: int, division: int, page: int,
+    def _post_main_battlefield_travel(self, side_id: int, battle_id: int) -> Response:
-                            damage: bool) -> Response:
+        data = dict(_token=self.token, sideCountryId=side_id, battleId=battle_id)
-        data = dict(battleId=battle, zoneId=zone, action="battleStatistics", round=round_id, division=division,
+        return self.post("{}/main/battlefieldTravel".format(self.url), data=data)
-                    leftPage=page, rightPage=page, _token=self.token)
-        if damage:
-            data.update({"type": "damage"})
-        else:
-            data.update({"type": "kills"})
 
-        return self.post("{}/military/battle-console".format(self.url), data=data)
+    def _post_main_buy_gold_items(self, currency: str, item: str, amount: int) -> Response:
-
-    def post_buy_gold_items(self, currency: str, item: str, amount: int) -> Response:
         data = dict(itemId=item, currency=currency, amount=amount, _token=self.token)
         return self.post("{}/main/buyGoldItems".format(self.url), data=data)
 
-    def post_candidate_for_congress(self, presentation: str = "") -> Response:
+    def _post_candidate_for_congress(self, presentation: str = "") -> Response:
         data = dict(_token=self.token, presentation=presentation)
         return self.post("{}/candidate-for-congress".format(self.url), data=data)
 
-    def post_citizen_add_remove_friend(self, citizen: int, add: bool) -> Response:
+    def _post_main_citizen_add_remove_friend(self, citizen: int, add: bool) -> Response:
         data = dict(_token=self.token, citizenId=citizen, url="//www.erepublik.com/en/main/citizen-addRemoveFriend")
         if add:
             data.update({"action": "addFriend"})
@@ -580,69 +606,83 @@ class CitizenAPI:
             data.update({"action": "removeFriend"})
         return self.post("{}/main/citizen-addRemoveFriend".format(self.url), data=data)
 
-    def post_collect_anniversary_reward(self) -> Response:
+    def _post_main_collect_anniversary_reward(self) -> Response:
         return self.post("{}/main/collect-anniversary-reward".format(self.url), data={"_token": self.token})
 
-    def post_country_donate(self, country: int, action: str, value: Union[int, float], quality: int = None):
+    def _post_main_country_donate(self, country: int, action: str, value: Union[int, float],
+                                  quality: int = None) -> Response:
         json = dict(countryId=country, action=action, _token=self.token, value=value, quality=quality)
         return self.post("{}/main/country-donate".format(self.url), data=json,
                          headers={"Referer": "{}/country/economy/Latvia".format(self.url)})
 
-    def post_daily_task_reward(self) -> Response:
+    def _post_main_daily_task_reward(self) -> Response:
         return self.post("{}/main/daily-tasks-reward".format(self.url), data=dict(_token=self.token))
 
-    def post_delete_message(self, msg_id: list) -> Response:
+    def _post_main_donate_article(self, article_id: int, amount: int) -> Response:
+        data = dict(_token=self.token, articleId=article_id, amount=amount)
+        return self.post("{}/main/donate-article".format(self.url), data=data)
+
+    def _post_delete_message(self, msg_id: list) -> Response:
         data = {"_token": self.token, "delete_message[]": msg_id}
         return self.post("{}/main/messages-delete".format(self.url), data)
 
-    def post_eat(self, color: str) -> Response:
+    def _post_eat(self, color: str) -> Response:
         data = dict(_token=self.token, buttonColor=color)
         return self.post("{}/main/eat".format(self.url), params=data)
 
-    def post_economy_activate_house(self, quality: int) -> Response:
+    def _post_economy_activate_booster(self, quality: int, duration: int, kind: str) -> Response:
+        data = dict(type=kind, quality=quality, duration=duration, fromInventory=True)
+        return self.post("{}/economy/activateBooster".format(self.url), data=data)
+
+    def _post_economy_activate_house(self, quality: int) -> Response:
         data = {"action": "activate", "quality": quality, "type": "house", "_token": self.token}
         return self.post("{}/economy/activateHouse".format(self.url), data=data)
 
-    def post_economy_assign_to_holding(self, factory: int, holding: int) -> Response:
+    def _post_economy_assign_to_holding(self, factory: int, holding: int) -> Response:
         data = dict(_token=self.token, factoryId=factory, action="assign", holdingCompanyId=holding)
         return self.post("{}/economy/assign-to-holding".format(self.url), data=data)
 
-    def post_economy_create_company(self, industry: int, building_type: int = 1) -> Response:
+    def _post_economy_create_company(self, industry: int, building_type: int = 1) -> Response:
         data = {"_token": self.token, "company[industry_id]": industry, "company[building_type]": building_type}
         return self.post("{}/economy/create-company".format(self.url), data=data,
                          headers={"Referer": "{}/economy/create-company".format(self.url)})
 
-    def post_economy_donate_items_action(self, citizen: int, amount: int, industry: int,
+    def _post_economy_donate_items_action(self, citizen: int, amount: int, industry: int,
-                                         quality: int) -> Response:
+                                          quality: int) -> Response:
         data = dict(citizen_id=citizen, amount=amount, industry_id=industry, quality=quality, _token=self.token)
         return self.post("{}/economy/donate-items-action".format(self.url), data=data,
                          headers={"Referer": "{}/economy/donate-items/{}".format(self.url, citizen)})
 
-    def post_economy_donate_money_action(self, citizen: int, amount: float = 0.0,
+    def _post_economy_donate_money_action(self, citizen: int, amount: float = 0.0,
-                                         currency: int = 62) -> Response:
+                                          currency: int = 62) -> Response:
         data = dict(citizen_id=citizen, _token=self.token, currency_id=currency, amount=amount)
         return self.post("{}/economy/donate-money-action".format(self.url), data=data,
                          headers={"Referer": "{}/economy/donate-money/{}".format(self.url, citizen)})
 
-    def post_economy_exchange_purchase(self, amount: float, currency: int, offer: int) -> Response:
+    def _post_economy_exchange_purchase(self, amount: float, currency: int, offer: int) -> Response:
         data = dict(_token=self.token, amount=amount, currencyId=currency, offerId=offer)
         return self.post("{}/economy/exchange/purchase/".format(self.url), data=data)
 
-    def post_economy_exchange_retrieve(self, personal: bool, page: int, currency: int) -> Response:
+    def _post_economy_exchange_retrieve(self, personal: bool, page: int, currency: int) -> Response:
         data = dict(_token=self.token, personalOffers=int(personal), page=page, currencyId=currency)
         return self.post("{}/economy/exchange/retrieve/".format(self.url), data=data)
 
-    def post_economy_job_market_apply(self, citizen: int, salary: int) -> Response:
+    def _post_economy_game_tokens_market(self, action: str) -> Response:
+        assert action in ['retrieve', ]
+        data = dict(_token=self.token, action=action)
+        return self.post("{}/economy/gameTokensMarketAjax".format(self.url), data=data)
+
+    def _post_economy_job_market_apply(self, citizen: int, salary: int) -> Response:
         data = dict(_token=self.token, citizenId=citizen, salary=salary)
         return self.post("{}/economy/job-market-apply".format(self.url), data=data)
 
-    def post_economy_marketplace(self, country: int, industry: int, quality: int,
+    def _post_economy_marketplace(self, country: int, industry: int, quality: int,
-                                 order_asc: bool = True) -> Response:
+                                  order_asc: bool = True) -> Response:
         data = dict(countryId=country, industryId=industry, quality=quality, ajaxMarket=1,
                     orderBy="price_asc" if order_asc else "price_desc", _token=self.token)
         return self.post("{}/economy/marketplaceAjax".format(self.url), data=data)
 
-    def post_economy_marketplace_actions(self, amount: int, buy: bool = False, **kwargs) -> Response:
+    def _post_economy_marketplace_actions(self, amount: int, buy: bool = False, **kwargs) -> Response:
         if buy:
             data = dict(_token=self.token, offerId=kwargs['offer'], amount=amount, orderBy="price_asc", currentPage=1,
                         buyAction=1)
@@ -651,24 +691,24 @@ class CitizenAPI:
                         industryId=kwargs["industry"], quality=kwargs["quality"], amount=amount, sellAction='postOffer')
         return self.post("{}/economy/marketplaceActions".format(self.url), data=data)
 
-    def post_economy_resign(self) -> Response:
+    def _post_economy_resign(self) -> Response:
         return self.post("{}/economy/resign".format(self.url),
                          headers={"Content-Type": "application/x-www-form-urlencoded"},
                          data={"_token": self.token, "action_type": "resign"})
 
-    def post_economy_sell_company(self, factory: int, pin: int = None, sell: bool = True) -> Response:
+    def _post_economy_sell_company(self, factory: int, pin: int = None, sell: bool = True) -> Response:
-        url = "{}/economy/sell-company/{}".format(self.url, factory)
         data = dict(_token=self.token, pin="" if pin is None else pin)
         if sell:
             data.update({"sell": "sell"})
         else:
             data.update({"dissolve": factory})
-        return self.post(url, data=data, headers={"Referer": url})
+        return self.post("{}/economy/sell-company/{}".format(self.url, factory),
+                         data=data, headers={"Referer": self.url})
 
-    def post_economy_train(self, tg_ids: List[int]) -> Response:
+    def _post_economy_train(self, tg_ids: List[int]) -> Response:
         data: Dict[str, Union[int, str]] = {}
         if not tg_ids:
-            return self.get_training_grounds_json()
+            return self._get_main_training_grounds_json()
         else:
             for idx, tg_id in enumerate(tg_ids):
                 data["grounds[%i][id]" % idx] = tg_id
@@ -677,11 +717,11 @@ class CitizenAPI:
             data['_token'] = self.token
         return self.post("{}/economy/train".format(self.url), data=data)
 
-    def post_economy_upgrade_company(self, factory: int, level: int, pin: str = None) -> Response:
+    def _post_economy_upgrade_company(self, factory: int, level: int, pin: str = None) -> Response:
         data = dict(_token=self.token, type="upgrade", companyId=factory, level=level, pin="" if pin is None else pin)
         return self.post("{}/economy/upgrade-company".format(self.url), data=data)
 
-    def post_economy_work(self, action_type: str, wam: List[int] = None, employ: Dict[int, int] = None):
+    def _post_economy_work(self, action_type: str, wam: List[int] = None, employ: Dict[int, int] = None) -> Response:
         """
         :return: requests.Response or None
         """
@@ -690,87 +730,100 @@ class CitizenAPI:
         if wam is None:
             wam = []
         data: Dict[str, Union[int, str]] = dict(action_type=action_type, _token=self.token)
-        if action_type == "work":
+        if action_type == "production":
-            return self.post("{}/economy/work".format(self.url), data=data)
-        elif action_type == "production":
             max_idx = 0
-            for idx, company_id in enumerate(sorted(wam or [])):
+            for company_id in sorted(wam or []):
                 data.update({
-                    "companies[%i][id]" % idx: company_id,
+                    "companies[%i][id]" % max_idx: company_id,
-                    "companies[%i][employee_works]" % idx: employ.pop(company_id, 0),
+                    "companies[%i][employee_works]" % max_idx: employ.pop(company_id, 0),
-                    "companies[%i][own_work]" % idx: 1
+                    "companies[%i][own_work]" % max_idx: 1
                 })
-                max_idx = idx + 1
+                max_idx += 1
-            for idx, company_id in enumerate(sorted(employ or [])):
+            for company_id in sorted(employ or []):
-                idx_ = idx + max_idx
                 data.update({
-                    "companies[%i][id]" % idx_: company_id,
+                    "companies[%i][id]" % max_idx: company_id,
-                    "companies[%i][employee_works]" % idx_: employ.pop(company_id),
+                    "companies[%i][employee_works]" % max_idx: employ.pop(company_id),
-                    "companies[%i][own_work]" % idx_: 0
+                    "companies[%i][own_work]" % max_idx: 0
                 })
-            return self.post("{}/economy/work".format(self.url), data=data)
+                max_idx += 1
-        else:
+        return self.post("{}/economy/work".format(self.url), data=data)
-            return
 
-    def post_economy_work_overtime(self) -> Response:
+    def _post_economy_work_overtime(self) -> Response:
         data = dict(action_type="workOvertime", _token=self.token)
         return self.post("{}/economy/workOvertime".format(self.url), data=data)
 
-    def post_forgot_password(self, email: str) -> Response:
+    def _post_forgot_password(self, email: str) -> Response:
         data = dict(_token=self.token, email=email, commit="Reset password")
         return self.post("{}/forgot-password".format(self.url), data=data)
 
-    def post_fight_activate_booster(self, battle: int, quality: int, duration: int, kind: str) -> Response:
+    def _post_military_fight_activate_booster(self, battle: int, quality: int, duration: int, kind: str) -> Response:
         data = dict(type=kind, quality=quality, duration=duration, battleId=battle, _token=self.token)
         return self.post("{}/military/fight-activateBooster".format(self.url), data=data)
 
-    def post_login(self, email: str, password: str) -> Response:
+    def _post_login(self, email: str, password: str) -> Response:
         data = dict(csrf_token=self.token, citizen_email=email, citizen_password=password, remember='on')
         return self.post("{}/login".format(self.url), data=data)
 
-    def post_messages_alert(self, notification_ids: list) -> Response:
+    def _post_main_messages_alert(self, notification_ids: List[int]) -> Response:
         data = {"_token": self.token, "delete_alerts[]": notification_ids, "deleteAllAlerts": "1", "delete": "Delete"}
         return self.post("{}/main/messages-alerts/1".format(self.url), data=data)
 
-    def post_messages_compose(self, subject: str, body: str, citizens: List[int]) -> Response:
+    def _post_main_messages_compose(self, subject: str, body: str, citizens: List[int]) -> Response:
         url_pk = 0 if len(citizens) > 1 else str(citizens[0])
         data = dict(citizen_name=",".join([str(x) for x in citizens]),
                     citizen_subject=subject, _token=self.token, citizen_message=body)
-        return self.post("{}/main/messages-compose/{}}".format(self.url, url_pk), data=data)
+        return self.post("{}/main/messages-compose/{}".format(self.url, url_pk), data=data)
 
-    def post_military_battle_console(self, battle_id: int, round_id: int, division: int) -> Response:
+    def _post_military_battle_console(self, battle_id: int, action: str, page: int = 1, **kwargs) -> Response:
-        data = dict(battleId=battle_id, zoneId=round_id, action="battleStatistics", round=round_id, division=division,
+        data = dict(battleId=battle_id, action=action, _token=self.token)
-                    type="damage", leftPage=1, rightPage=1, _token=self.token)
+        if action == "battleStatistics":
-        return self.post("{}/military/battle-console".format(self.url, battle_id), data=data)
+            data.update(round=kwargs["round_id"], zoneId=kwargs["round_id"], leftPage=page, rightPage=page,
+                        division=kwargs["division"], type=kwargs.get("type", 'damage'), )
+        elif action == "warList":
+            data.update(page=page)
+        return self.post("{}/military/battle-console".format(self.url), data=data)
 
-    def post_military_fight_air(self, battle_id: int, side_id: int) -> Response:
+    def _post_military_change_weapon(self, battle_id: int, battle_zone_id: int, customization_level: int) -> Response:
+        data = dict(_token=self.token, battleZoneId=battle_zone_id, battleId=battle_id,
+                    customizationLevel=customization_level)
+        return self.post("{}/military/change-weapon".format(self.url), data=data)
+
+    def _post_military_deploy_bomb(self, battle_id: int, bomb_id: int) -> Response:
+        data = dict(battleId=battle_id, bombId=bomb_id, _token=self.token)
+        return self.post("{}/military/deploy-bomb".format(self.url), data=data)
+
+    def _post_military_fight_air(self, battle_id: int, side_id: int) -> Response:
         data = dict(sideId=side_id, battleId=battle_id, _token=self.token)
         return self.post("{}/military/fight-shoooot/{}".format(self.url, battle_id), data=data)
 
-    def post_military_fight_ground(self, battle_id: int, side_id: int) -> Response:
+    def _post_military_fight_ground(self, battle_id: int, side_id: int) -> Response:
         data = dict(sideId=side_id, battleId=battle_id, _token=self.token)
         return self.post("{}/military/fight-shooot/{}".format(self.url, battle_id), data=data)
 
-    def post_military_group_missions(self) -> Response:
+    def _post_military_group_missions(self) -> Response:
         data = dict(action="check", _token=self.token)
         return self.post("{}/military/group-missions".format(self.url), data=data)
 
-    def post_travel(self, check: str, **kwargs) -> Response:
+    def _post_main_travel(self, check: str, **kwargs) -> Response:
         data = dict(_token=self.token, check=check, **kwargs)
         return self.post("{}/main/travel".format(self.url), data=data)
 
-    def post_travel_data(self, **kwargs) -> Response:
+    def _post_main_vote_article(self, article_id: int) -> Response:
+        data = dict(_token=self.token, articleId=article_id)
+        return self.post("{}/main/vote-article".format(self.url), data=data)
+
+    def _post_main_travel_data(self, **kwargs) -> Response:
         return self.post("{}/main/travelData".format(self.url), data=dict(_token=self.token, **kwargs))
 
-    def post_wars_attack_region(self, war: int, region: int) -> Response:
+    def _post_wars_attack_region(self, war_id: int, region_id: int, region_name: str) -> Response:
-        data = dict(_token=self.token)
+        data = {'_token': self.token, 'warId': war_id, 'regionName': region_name, 'regionNameConfirm': region_name}
-        return self.post("{}/wars/attack-region/{}/{}".format(self.url, war, region), data=data)
+        return self.post('{}/wars/attack-region/{}/{}'.format(self.url, war_id, region_id), data=data)
 
-    def post_weekly_challenge_reward(self, reward_id: int) -> Response:
+    def _post_main_weekly_challenge_reward(self, reward_id: int) -> Response:
         data = dict(_token=self.token, rewardId=reward_id)
         return self.post("{}/main/weekly-challenge-collect-reward".format(self.url), data=data)
 
-    def post_write_article(self, title: str, content: str, location: int, kind: int) -> Response:
+    def _post_main_write_article(self, title: str, content: str, location: int, kind: int) -> Response:
         data = dict(_token=self.token, article_name=title, article_body=content, article_location=location,
                     article_category=kind)
         return self.post("{}/main/write-article".format(self.url), data=data)
@@ -778,73 +831,73 @@ class CitizenAPI:
     # Wall Posts
     # ## Country
 
-    def post_country_comment_retrieve(self, post_id: int):
+    def _post_main_country_comment_retrieve(self, post_id: int) -> Response:
         data = {"_token": self.token, "postId": post_id}
         return self.post("{}/main/country-comment/retrieve/json".format(self.url), data=data)
 
-    def post_country_comment_create(self, post_id: int, comment_message: str):
+    def _post_main_country_comment_create(self, post_id: int, comment_message: str) -> Response:
         data = {"_token": self.token, "postId": post_id, 'comment_message': comment_message}
         return self.post("{}/main/country-comment/create/json".format(self.url), data=data)
 
-    def post_country_post_create(self, body: str, post_as: int):
+    def _post_main_country_post_create(self, body: str, post_as: int) -> Response:
         data = {"_token": self.token, "post_message": body, "post_as": post_as}
         return self.post("{}/main/country-post/create/json".format(self.url), data=data)
 
-    def post_country_post_retrieve(self):
+    def _post_main_country_post_retrieve(self) -> Response:
         data = {"_token": self.token, "page": 1, "switchedFrom": False}
         return self.post("{}/main/country-post/retrieve/json".format(self.url), data=data)
 
     # ## Military Unit
 
-    def post_military_unit_comment_retrieve(self, post_id: int):
+    def _post_main_military_unit_comment_retrieve(self, post_id: int) -> Response:
         data = {"_token": self.token, "postId": post_id}
         return self.post("{}/main/military-unit-comment/retrieve/json".format(self.url), data=data)
 
-    def post_military_unit_comment_create(self, post_id: int, comment_message: str):
+    def _post_main_military_unit_comment_create(self, post_id: int, comment_message: str) -> Response:
         data = {"_token": self.token, "postId": post_id, 'comment_message': comment_message}
         return self.post("{}/main/military-unit-comment/create/json".format(self.url), data=data)
 
-    def post_military_unit_post_create(self, body: str, post_as: int):
+    def _post_main_military_unit_post_create(self, body: str, post_as: int) -> Response:
         data = {"_token": self.token, "post_message": body, "post_as": post_as}
         return self.post("{}/main/military-unit-post/create/json".format(self.url), data=data)
 
-    def post_military_unit_post_retrieve(self):
+    def _post_main_military_unit_post_retrieve(self) -> Response:
         data = {"_token": self.token, "page": 1, "switchedFrom": False}
         return self.post("{}/main/military-unit-post/retrieve/json".format(self.url), data=data)
 
     # ## Party
 
-    def post_party_comment_retrieve(self, post_id: int):
+    def _post_main_party_comment_retrieve(self, post_id: int) -> Response:
         data = {"_token": self.token, "postId": post_id}
         return self.post("{}/main/party-comment/retrieve/json".format(self.url), data=data)
 
-    def post_party_comment_create(self, post_id: int, comment_message: str):
+    def _post_main_party_comment_create(self, post_id: int, comment_message: str) -> Response:
         data = {"_token": self.token, "postId": post_id, 'comment_message': comment_message}
         return self.post("{}/main/party-comment/create/json".format(self.url), data=data)
 
-    def post_party_post_create(self, body: str):
+    def _post_main_party_post_create(self, body: str) -> Response:
         data = {"_token": self.token, "post_message": body}
         return self.post("{}/main/party-post/create/json".format(self.url), data=data)
 
-    def post_party_post_retrieve(self):
+    def _post_main_party_post_retrieve(self) -> Response:
         data = {"_token": self.token, "page": 1, "switchedFrom": False}
         return self.post("{}/main/party-post/retrieve/json".format(self.url), data=data)
 
     # ## Friend's Wall
 
-    def post_wall_comment_retrieve(self, post_id: int):
+    def _post_main_wall_comment_retrieve(self, post_id: int) -> Response:
         data = {"_token": self.token, "postId": post_id}
         return self.post("{}/main/wall-comment/retrieve/json".format(self.url), data=data)
 
-    def post_wall_comment_create(self, post_id: int, comment_message: str):
+    def _post_main_wall_comment_create(self, post_id: int, comment_message: str) -> Response:
         data = {"_token": self.token, "postId": post_id, 'comment_message': comment_message}
         return self.post("{}/main/wall-comment/create/json".format(self.url), data=data)
 
-    def post_wall_post_create(self, body: str):
+    def _post_main_wall_post_create(self, body: str) -> Response:
         data = {"_token": self.token, "post_message": body}
         return self.post("{}/main/wall-post/create/json".format(self.url), data=data)
 
-    def post_wall_post_retrieve(self):
+    def _post_main_wall_post_retrieve(self) -> Response:
         data = {"_token": self.token, "page": 1, "switchedFrom": False}
         return self.post("{}/main/wall-post/retrieve/json".format(self.url), data=data)
 
@@ -928,11 +981,12 @@ class Reporter:
 
 class MyJSONEncoder(JSONEncoder):
     def default(self, o):
+        from erepublik.citizen import Citizen
         if isinstance(o, decimal.Decimal):
             return float("{:.02f}".format(o))
         elif isinstance(o, datetime.datetime):
             return dict(__type__='datetime', year=o.year, month=o.month, day=o.day, hour=o.hour, minute=o.minute,
-                        second=o.second, microsecond=o.microsecond)
+                        second=o.second, microsecond=o.microsecond, tzinfo=o.tzinfo.zone if o.tzinfo else None)
         elif isinstance(o, datetime.date):
             return dict(__type__='date', year=o.year, month=o.month, day=o.day)
         elif isinstance(o, datetime.timedelta):
@@ -944,14 +998,16 @@ class MyJSONEncoder(JSONEncoder):
             return o.__dict__
         elif isinstance(o, deque):
             return list(o)
+        elif isinstance(o, Citizen):
+            return o.to_json()
         return super().default(o)
 
 
 class BattleSide:
     id: int
     points: int
-    deployed: List[int] = list()
+    deployed: List[int] = None
-    allies: List[int] = list()
+    allies: List[int] = None
 
     def __init__(self, country_id: int, points: int, allies: List[int], deployed: List[int]):
         self.id = country_id
@@ -959,12 +1015,20 @@ class BattleSide:
         self.allies = [int(ally) for ally in allies]
         self.deployed = [int(ally) for ally in deployed]
 
+    @property
+    def __dict__(self):
+        ret = {}
+        for key in dir(self):
+            if not key.startswith('_'):
+                ret[key] = getattr(self, key)
+        return ret
+
 
 class BattleDivision:
     end: datetime.datetime
     epic: bool
-    dom_pts: Dict[str, int] = dict()
+    dom_pts: Dict[str, int] = None
-    wall: Dict[str, Union[int, float]] = dict()
+    wall: Dict[str, Union[int, float]] = None
 
     @property
     def div_end(self) -> bool:
@@ -973,8 +1037,16 @@ class BattleDivision:
     def __init__(self, end: datetime.datetime, epic: bool, inv_pts: int, def_pts: int, wall_for: int, wall_dom: float):
         self.end = end
         self.epic = epic
-        self.dom_pts.update({"inv": inv_pts, "def": def_pts})
+        self.dom_pts = dict({"inv": inv_pts, "def": def_pts})
-        self.wall.update({"for": wall_for, "dom": wall_dom})
+        self.wall = dict({"for": wall_for, "dom": wall_dom})
+
+    @property
+    def __dict__(self):
+        ret = {}
+        for key in dir(self):
+            if not key.startswith('_'):
+                ret[key] = getattr(self, key)
+        return ret
 
 
 class Battle(object):
@@ -986,13 +1058,13 @@ class Battle(object):
     start: datetime.datetime = None
     invader: BattleSide = None
     defender: BattleSide = None
-    div: Dict[int, BattleDivision] = dict()
+    div: Dict[int, BattleDivision] = None
 
     @property
     def is_air(self) -> bool:
         return not bool(self.zone_id % 4)
 
-    def __init__(self, battle: dict):
+    def __init__(self, battle: Dict[str, Any]):
         self.id = int(battle.get('id', 0))
         self.war_id = int(battle.get('war_id', 0))
         self.zone_id = int(battle.get('zone_id', 0))
@@ -1009,12 +1081,13 @@ class Battle(object):
                                    [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.div = {}
         for div, data in battle.get('div', {}).items():
-            div = int(div)
+            div = int(data.get('div'))
             if data.get('end'):
                 end = datetime.datetime.fromtimestamp(data.get('end'), tz=utils.erep_tz)
             else:
-                end = datetime.datetime.max
+                end = utils.localize_dt(datetime.datetime.max - datetime.timedelta(days=1))
 
             battle_div = BattleDivision(
                 end=end, epic=data.get('epic_type') in [1, 5],
@@ -1035,6 +1108,14 @@ class Battle(object):
             self.id, utils.COUNTRIES[self.invader.id], utils.COUNTRIES[self.defender.id], self.zone_id, time_part
         )
 
+    @property
+    def __dict__(self):
+        ret = {}
+        for key in dir(self):
+            if not key.startswith('_'):
+                ret[key] = getattr(self, key)
+        return ret
+
 
 class EnergyToFight:
     energy: int = 0
@@ -1065,3 +1146,57 @@ class EnergyToFight:
         if 0 < new_energy < self.energy:
             self.energy = new_energy
         return self.energy
+
+
+class TelegramBot:
+    __initialized = False
+    __queue: List[str] = []
+    chat_id = 0
+    api_url = ""
+    player_name = ""
+    __last_time: datetime.datetime = None
+
+    def do_init(self, chat_id: int, token: str, player_name: str = ""):
+        self.chat_id = chat_id
+        self.api_url = "https://api.telegram.org/bot{}/sendMessage".format(token)
+        self.player_name = player_name
+        self.__initialized = True
+        self.__last_time = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-5))
+        if self.__queue:
+            self.send_message("\n\n––––––––––––––––––––––\n\n".join(self.__queue))
+
+    def send_message(self, message: str) -> bool:
+        if not self.__initialized:
+            self.__queue.append(message)
+            return True
+        if self.player_name:
+            message = f"Player *{self.player_name}*\n" + message
+        if utils.good_timedelta(utils.now(), datetime.timedelta(seconds=-1)) <= self.__last_time:
+            tb = traceback.extract_stack()
+            message += "\n\n```\n{}\n```".format("\n".join(['  File "{}", line {}, in {}\n'.format(l.filename, l.lineno, l.name) for l in tb]))
+        response = post(self.api_url, json=dict(chat_id=self.chat_id, text=message, parse_mode="Markdown"))
+        self.__last_time = utils.now()
+        return response.json().get('ok')
+
+    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):
+        message = f"Full energy ({available}hp/{limit}hp +{interval}hp/6min)"
+        self.send_message(message)
+
+    def report_medal(self, msg):
+        self.send_message(f"New award: *{msg}*")

erepublik/utils.py

@@ -7,16 +7,11 @@ import sys
 import time
 import traceback
 import unicodedata
-from collections import deque
-from decimal import Decimal
-from json import JSONEncoder
 from pathlib import Path
-from typing import Union
+from typing import Union, Any, List, NoReturn, Mapping
 
 import pytz
 import requests
-from requests import Response
-
 
 __all__ = ["FOOD_ENERGY", "COMMIT_ID", "COUNTRIES", "erep_tz",
            "now", "localize_dt", "localize_timestamp", "good_timedelta", "eday_from_date", "date_from_eday",
@@ -24,7 +19,6 @@ __all__ = ["FOOD_ENERGY", "COMMIT_ID", "COUNTRIES", "erep_tz",
            "write_silent_log", "write_interactive_log", "get_file", "write_file",
            "send_email", "normalize_html_json", "process_error", ]
 
-
 FOOD_ENERGY = dict(q1=2, q2=4, q3=6, q4=8, q5=10, q6=12, q7=20)
 COMMIT_ID = "7b92e19"
 
@@ -85,40 +79,37 @@ COUNTRIES = {1: 'Romania', 9: 'Brazil', 10: 'Italy', 11: 'France', 12: 'Germany'
              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 = {1: 'Romania', 9: 'Brazil', 11: 'France', 12: 'Germany', 13: 'Hungary', 82: 'Cyprus', 168: 'Georgia',
-class MyJSONEncoder(JSONEncoder):
+                15: 'Spain', 23: 'Canada', 26: 'Mexico', 27: 'Argentina', 28: 'Venezuela', 80: 'Montenegro', 24: 'USA',
-    def default(self, o):
+                29: 'United-Kingdom', 50: 'Australia', 47: 'South-Korea', 171: 'Cuba',
-        if isinstance(o, Decimal):
+                79: 'Republic-of-Macedonia-FYROM',
-            return float("{:.02f}".format(o))
+                30: 'Switzerland', 31: 'Netherlands', 32: 'Belgium', 33: 'Austria', 34: 'Czech-Republic', 35: 'Poland',
-        elif isinstance(o, datetime.datetime):
+                36: 'Slovakia', 37: 'Norway', 38: 'Sweden', 39: 'Finland', 40: 'Ukraine', 41: 'Russia', 42: 'Bulgaria',
-            return dict(__type__='datetime', year=o.year, month=o.month, day=o.day, hour=o.hour, minute=o.minute,
+                43: 'Turkey', 44: 'Greece', 45: 'Japan', 48: 'India', 49: 'Indonesia', 78: 'Colombia', 68: 'Singapore',
-                        second=o.second, microsecond=o.microsecond)
+                51: 'South Africa', 52: 'Republic-of-Moldova', 53: 'Portugal', 54: 'Ireland', 55: 'Denmark', 56: 'Iran',
-        elif isinstance(o, datetime.date):
+                57: 'Pakistan', 58: 'Israel', 59: 'Thailand', 61: 'Slovenia', 63: 'Croatia', 64: 'Chile', 65: 'Serbia',
-            return dict(__type__='date', year=o.year, month=o.month, day=o.day)
+                66: 'Malaysia', 67: 'Philippines', 70: 'Estonia', 165: 'Egypt', 14: 'China', 77: 'Peru', 10: 'Italy',
-        elif isinstance(o, datetime.timedelta):
+                71: 'Latvia', 72: 'Lithuania', 73: 'North-Korea', 74: 'Uruguay', 75: 'Paraguay', 76: 'Bolivia',
-            return dict(__type__='timedelta', days=o.days, seconds=o.seconds,
+                81: 'Republic-of-China-Taiwan', 166: 'United-Arab-Emirates', 167: 'Albania', 69: 'Bosnia-Herzegovina',
-                        microseconds=o.microseconds, total_seconds=o.total_seconds())
+                169: 'Armenia', 83: 'Belarus', 84: 'New-Zealand', 164: 'Saudi-Arabia', 170: 'Nigeria', }
-        elif isinstance(o, Response):
-            return dict(headers=o.headers.__dict__, url=o.url, text=o.text)
-        elif hasattr(o, '__dict__'):
-            return o.__dict__
-        elif isinstance(o, deque):
-            return list(o)
-        return super().default(o)
 
 
-def now():
+def now() -> datetime.datetime:
     return datetime.datetime.now(erep_tz).replace(microsecond=0)
 
 
-def localize_timestamp(timestamp: int):
+def localize_timestamp(timestamp: int) -> datetime.datetime:
     return datetime.datetime.fromtimestamp(timestamp, erep_tz)
 
 
-def localize_dt(dt: Union[datetime.date, datetime.datetime]):
+def localize_dt(dt: Union[datetime.date, datetime.datetime]) -> datetime.datetime:
-    if isinstance(dt, datetime.date):
+    try:
-        dt = datetime.datetime.combine(dt, datetime.time(0, 0, 0))
+        try:
-    return erep_tz.localize(dt)
+            return erep_tz.localize(dt)
+        except AttributeError:
+            return erep_tz.localize(datetime.datetime.combine(dt, datetime.time(0, 0, 0)))
+    except ValueError:
+        return dt.astimezone(erep_tz)
 
 
 def good_timedelta(dt: datetime.datetime, td: datetime.timedelta) -> datetime.datetime:
@@ -237,7 +228,10 @@ def write_request(response: requests.Response, is_error: bool = False):
                 "mimetype": "application/json" if ext == "json" else "text/html"}
 
 
-def send_email(name: str, content: list, player=None, local_vars=dict, promo: bool = False, captcha: bool = False):
+def send_email(name: str, content: List[Any], player=None, local_vars: Mapping[Any, Any] = None,
+               promo: bool = False, captcha: bool = False):
+    if local_vars is None:
+        local_vars = {}
     from erepublik import Citizen
 
     file_content_template = "<html><head><title>{title}</title></head><body>{body}</body></html>"
@@ -277,6 +271,7 @@ def send_email(name: str, content: list, player=None, local_vars=dict, promo: bo
     if local_vars:
         if "state_thread" in local_vars:
             local_vars.pop('state_thread', None)
+        from erepublik.classes import MyJSONEncoder
         files.append(('file', ("local_vars.json", json.dumps(local_vars, indent=2,
                                                              cls=MyJSONEncoder, sort_keys=True), "application/json")))
     if isinstance(player, Citizen):
@@ -319,7 +314,11 @@ def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commi
     send_email(name, bugtrace, citizen, local_vars=trace)
 
 
-def slugify(value, allow_unicode=False):
+def report_promo(kind: str, time_untill: datetime.datetime) -> NoReturn:
+    requests.post('https://api.erep.lv/promos/add/', data=dict(kind=kind, time_untill=time_untill))
+
+
+def slugify(value, allow_unicode=False) -> str:
     """
     Function copied from Django2.2.1 django.utils.text.slugify
     Convert to ASCII if 'allow_unicode' is False. Convert spaces to hyphens.
@@ -331,5 +330,5 @@ def slugify(value, allow_unicode=False):
         value = unicodedata.normalize('NFKC', value)
     else:
         value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore').decode('ascii')
-    value = re.sub(r'[^\w\s-]', '', value).strip().lower()
+    value = re.sub(r'[^\w\s-]', '_', value).strip().lower()
     return re.sub(r'[-\s]+', '-', value)

requirements_dev.txt

@@ -5,11 +5,10 @@ watchdog==0.9.0
 flake8==3.7.8
 tox==3.13.2
 coverage==4.5.3
-Sphinx==2.1.2
+Sphinx==2.2.0
-twine==1.13.0
+twine==2.0.0
-ipython==7.6.1
+ipython
-PyInstaller==3.5
+PyInstaller
 pytz==2019.1
 requests==2.22.0
-pycryptodome==3.8.2
+edx-sphinx-theme
-python-slugify==2.0.1

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.14.7
+current_version = 0.16.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.1', 'requests==2.22.0']
+requirements = ['pytz>=2019.2', 'requests>=2.22']
 
 setup_requirements = [ ]
 
@@ -41,7 +41,7 @@ setup(
     setup_requires=setup_requirements,
     test_suite='tests',
     tests_require=test_requirements,
-    url='https://github.com/eeriks/erepublik_script',
+    url='https://github.com/eeriks/erepublik/',
-    version='0.14.7',
+    version='0.16.0',
     zip_safe=False,
 )

tests/test_erepublik_script.py

@@ -5,30 +5,126 @@
 
 
 import unittest
-from click.testing import CliRunner
 
 from erepublik import Citizen
-from erepublik import cli
 
 
-class TestErepublik_script(unittest.TestCase):
+class TestErepublik(unittest.TestCase):
     """Tests for `erepublik` package."""
 
     def setUp(self):
         """Set up test fixtures, if any."""
+        self.citizen = Citizen("email", "password", False)
+        self.citizen.config.interactive = False
 
-    def tearDown(self):
+    def test_should_do_levelup(self):
-        """Tear down test fixtures, if any."""
+        self.citizen.energy.recovered = 1900
+        self.citizen.energy.recoverable = 2940
+        self.citizen.energy.interval = 30
+        self.citizen.energy.limit = 3000
+        self.citizen.details.xp = 14850
+        self.assertTrue(self.citizen.should_do_levelup)
 
-    def test_000_something(self):
+        self.citizen.energy.recoverable = 1000
-        """Test something."""
+        self.assertFalse(self.citizen.should_do_levelup)
+
+    def test_should_travel_to_fight(self):
+        self.citizen.config.always_travel = True
+        self.assertTrue(self.citizen.should_travel_to_fight())
+        self.citizen.config.always_travel = False
+        self.assertFalse(self.citizen.should_travel_to_fight())
+
+        self.citizen.energy.recovered = 1900
+        self.citizen.energy.recoverable = 2940
+        self.citizen.energy.interval = 30
+        self.citizen.energy.limit = 3000
+        self.citizen.details.xp = 14850
+        self.assertTrue(self.citizen.should_travel_to_fight())
+        self.citizen.details.xp = 15000
+        self.assertFalse(self.citizen.should_travel_to_fight())
+
+        self.citizen.energy.recovered = 3000
+        self.citizen.energy.recoverable = 2910
+        self.assertTrue(self.citizen.should_travel_to_fight())
+        self.citizen.energy.recoverable = 2900
+        self.assertFalse(self.citizen.should_travel_to_fight())
+
+        # self.citizen.next_reachable_energy and self.citizen.config.next_energy
+        self.citizen.config.next_energy = True
+        self.citizen.energy.limit = 5000
+        self.citizen.details.next_pp = [5000, 5250, 5750, 6250, 6750]
+        self.citizen.details.pp = 4900
+        self.citizen.energy.recovered = 4000
+        self.citizen.energy.recoverable = 4510
+        self.assertEqual(self.citizen.next_reachable_energy, 850)
+        self.citizen.energy.recoverable = 4490
+        self.assertTrue(self.citizen.should_travel_to_fight())
+        self.assertEqual(self.citizen.next_reachable_energy, 350)
+        self.citizen.energy.recovered = 100
+        self.citizen.energy.recoverable = 150
+        self.assertFalse(self.citizen.should_travel_to_fight())
+        self.assertEqual(self.citizen.next_reachable_energy, 0)
+
+    def test_should_fight(self):
+        self.citizen.config.fight = False
+        self.assertEqual(self.citizen.should_fight(), 0)
+
+        self.citizen.config.fight = True
+
+        # Level up
+        self.citizen.energy.limit = 3000
+        self.citizen.details.xp = 24705
+        self.assertEqual(self.citizen.should_fight(), 0)
+
+        self.citizen.energy.recovered = 3000
+        self.citizen.energy.recoverable = 2950
+        self.citizen.energy.interval = 30
+        self.assertEqual(self.citizen.should_fight(), 895)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 895)
+        self.citizen.my_companies.ff_lockdown = 0
+
+        # Level up reachable
+        self.citizen.details.xp = 24400
+        self.assertEqual(self.citizen.should_fight(), 305)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 305)
+        self.citizen.my_companies.ff_lockdown = 0
+
+        self.citizen.details.xp = 21000
+        self.assertEqual(self.citizen.should_fight(), 75)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 75)
+        self.citizen.my_companies.ff_lockdown = 0
+        self.citizen.details.pp = 80
+
+        # All-in (type = all-in and full ff)
+        self.citizen.config.all_in = True
+        self.assertEqual(self.citizen.should_fight(), 595)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 435)
+        self.citizen.my_companies.ff_lockdown = 0
+
+        self.citizen.config.air = True
+        self.citizen.energy.recoverable = 1000
+        self.assertEqual(self.citizen.should_fight(), 400)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 240)
+        self.citizen.my_companies.ff_lockdown = 0
+        self.citizen.config.all_in = False
+
+        self.citizen.config.next_energy = True
+        self.citizen.energy.limit = 5000
+        self.citizen.details.next_pp = [100, 150, 250, 400, 500]
+        self.assertEqual(self.citizen.should_fight(), 320)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 160)
+        self.citizen.my_companies.ff_lockdown = 0
+        self.citizen.energy.limit = 3000
+        self.citizen.details.next_pp = [19250, 20000]
+        self.citizen.config.next_energy = False
+
+        # 1h worth of energy
+        self.citizen.energy.recoverable = 2910
+        self.assertEqual(self.citizen.should_fight(), 30)
 
-    def test_command_line_interface(self):
-        """Test the CLI."""
-        runner = CliRunner()
-        result = runner.invoke(cli.main)
-        assert result.exit_code == 0
-        assert 'erepublik.cli.main' in result.output
-        help_result = runner.invoke(cli.main, ['--help'])
-        assert help_result.exit_code == 0
-        assert '--help  Show this message and exit.' in help_result.output

tox.ini

@@ -1,10 +1,9 @@
 [tox]
-envlist =  py36, py37, flake8
+envlist =  py37, flake8
 
 [travis]
 python =
     3.7: py37
-    3.6: py36
 
 [testenv:flake8]
 basepython = python