Bump version: 0.20.0 → 0.20.1

Company sorting bugfix

.editorconfig

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

.github/ISSUE_TEMPLATE.md

@@ -9,7 +9,7 @@ Tell us what happened, what went wrong, and what you expected to happen.
 
 ### What I Did
 
-```
+``` python
 Paste the command(s) you ran and the output.
 If there was a crash, please include the traceback here.
 ```

.github/workflows/pythonpackage.yml

@@ -0,0 +1,33 @@
+name: Python package
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.7, 3.8]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements_dev.txt
+    - name: Lint with flake8
+      run: |
+        pip install flake8
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        pip install pytest
+        pytest

.gitignore

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

.travis.yml

@@ -2,10 +2,10 @@
 
 language: python
 python:
+  - 3.8
   - 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

@@ -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:
 
@@ -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
 ~~~~~~~~~~~~~~~~~~
 
@@ -45,7 +39,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:
 
@@ -57,17 +51,17 @@ If you are proposing a feature:
 Get Started!
 ------------
 
-Ready to contribute? Here's how to set up `erepublik_script` for local development.
+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_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::
 
-    $ mkvirtualenv erepublik_script
-    $ cd erepublik_script/
+    $ mkvirtualenv erepublik
+    $ cd erepublik/
     $ python setup.py develop
 
 4. Create a branch for local development::
@@ -79,7 +73,7 @@ Ready to contribute? Here's how to set up `erepublik_script` for local developme
 5. When you're done making changes, check that your changes pass flake8 and the
    tests, including testing other Python versions with tox::
 
-    $ flake8 erepublik_script tests
+    $ flake8 erepublik tests
     $ python setup.py test or py.test
     $ tox
 
@@ -102,8 +96,8 @@ Before you submit a pull request, check that it meets these guidelines:
 2. If the pull request adds functionality, the docs should be updated. Put
    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 2.7, 3.4, 3.5 and 3.6, and for PyPy. Check
-   https://travis-ci.org/eeriks/erepublik_script/pull_requests
+3. The pull request should work for Python 3.7.1. Check
+   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,70 @@
 History
 =======
 
+0.20.0 (2020-06-15)
+-------------------
+* Massive restructuring
+* Restricted IP check
+* Bomb deploy improvements
+* More verbose action logging
+* Division switching for maverick scripts
+* New medal endpoint is correctly parsed
+* WAM/Employ modularized
+
+
+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)
+-------------------
+
+* 12th anniversary's endpoints added
+* Telegram message queue optimisation
+* WC end fighting energy bugfix
+* More strict fighting limiting before week change
+* Improved and fixed ground damage booster usage
+
+
+0.16.0 (2019-09-29)
+-------------------
+
+* 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
+
+
+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.
+
+
 0.1.0 (2019-07-19)
 ------------------
 

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/
@@ -51,7 +53,7 @@ clean-test: ## remove test and coverage artifacts
 	rm -fr .pytest_cache
 
 lint: ## check style with flake8
-	flake8 erepublik_script tests
+	flake8 erepublik tests
 
 test: ## run tests quickly with the default Python
 	python setup.py test
@@ -60,15 +62,15 @@ test-all: ## run tests on every Python version with tox
 	tox
 
 coverage: ## check code coverage quickly with the default Python
-	coverage run --source erepublik_script setup.py test
+	coverage run --source erepublik setup.py test
 	coverage report -m
 	coverage html
 	$(BROWSER) htmlcov/index.html
 
 docs: ## generate Sphinx HTML documentation, including API docs
-	rm -f docs/erepublik_script.rst
+	rm -f docs/erepublik.rst
 	rm -f docs/modules.rst
-	sphinx-apidoc -o docs/ erepublik_script
+	sphinx-apidoc -o docs/ erepublik
 	$(MAKE) -C docs clean
 	$(MAKE) -C docs html
 	$(BROWSER) docs/_build/html/index.html
@@ -86,3 +88,9 @@ dist: clean ## builds source and wheel package
 
 install: clean ## install the package to the active Python's site-packages
 	python setup.py install
+
+setcommit:
+	bash set_commit_id.sh
+# 	commit=`git log -1 --pretty=format:%h`
+# 	sed -i.bak -E "s|COMMIT_ID = \".+\"|COMMIT_ID = \"$(commit)\"|g" erepublik/utils.py
+# 	mv erepublik/utils.py.bak erepublik/utils.py

README.rst

@@ -3,11 +3,11 @@ eRepublik script
 ================
 
 
-.. image:: https://img.shields.io/pypi/v/erepublik_script.svg
-        :target: https://pypi.python.org/pypi/erepublik_script
+.. image:: https://img.shields.io/pypi/v/erepublik.svg
+        :target: https://pypi.python.org/pypi/erepublik
 
-.. image:: https://readthedocs.org/projects/erepublik-script/badge/?version=latest
-        :target: https://erepublik-script.readthedocs.io/en/latest/?badge=latest
+.. image:: https://readthedocs.org/projects/erepublik/badge/?version=latest
+        :target: https://erepublik.readthedocs.io/en/latest/?badge=latest
         :alt: Documentation Status
 
 
@@ -15,7 +15,7 @@ Python package for automated eRepublik playing
 
 
 * Free software: MIT license
-* Documentation: https://erepublik-script.readthedocs.io.
+* Documentation: https://erepublik.readthedocs.io/en/latest/
 
 
 Features

docs/Makefile

@@ -4,7 +4,7 @@
 # You can set these variables from the command line.
 SPHINXOPTS    =
 SPHINXBUILD   = python -msphinx
-SPHINXPROJ    = erepublik_script
+SPHINXPROJ    = erepublik
 SOURCEDIR     = .
 BUILDDIR      = _build
 

docs/conf.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-# erepublik_script documentation build configuration file, created by
+# erepublik documentation build configuration file, created by
 # sphinx-quickstart on Fri Jun  9 13:47:02 2017.
 #
 # This file is execfile()d with the current directory set to its
@@ -22,7 +22,8 @@ import os
 import sys
 sys.path.insert(0, os.path.abspath('..'))
 
-import erepublik_script
+import erepublik
+import edx_theme
 
 # -- General configuration ---------------------------------------------
 
@@ -32,7 +33,7 @@ import erepublik_script
 
 # 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']
@@ -56,9 +57,9 @@ author = u"Eriks Karls"
 # the built documents.
 #
 # The short X.Y version.
-version = erepublik_script.__version__
+version = erepublik.__version__
 # The full version, including alpha/beta/rc tags.
-release = erepublik_script.__version__
+release = erepublik.__version__
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -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
@@ -101,7 +103,7 @@ html_static_path = ['_static']
 # -- Options for HTMLHelp output ---------------------------------------
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = 'erepublik_scriptdoc'
+htmlhelp_basename = 'erepublikdoc'
 
 
 # -- Options for LaTeX output ------------------------------------------
@@ -128,7 +130,7 @@ latex_elements = {
 # (source start file, target name, title, author, documentclass
 # [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, 'erepublik_script.tex',
+    (master_doc, 'erepublik.tex',
      u'eRepublik script Documentation',
      u'Eriks Karls', 'manual'),
 ]
@@ -139,7 +141,7 @@ latex_documents = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    (master_doc, 'erepublik_script',
+    (master_doc, 'erepublik',
      u'eRepublik script Documentation',
      [author], 1)
 ]
@@ -151,13 +153,10 @@ man_pages = [
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (master_doc, 'erepublik_script',
+    (master_doc, 'erepublik',
      u'eRepublik script Documentation',
      author,
-     'erepublik_script',
+     'erepublik',
      'One line description of project.',
      'Miscellaneous'),
 ]
-
-
-

docs/index.rst

@@ -1,5 +1,5 @@
 Welcome to eRepublik script's documentation!
-======================================
+============================================
 
 .. toctree::
    :maxdepth: 2

docs/installation.rst

@@ -12,7 +12,7 @@ To install eRepublik script, run this command in your terminal:
 
 .. code-block:: console
 
-    $ pip install erepublik_script
+    $ pip install erepublik
 
 This is the preferred method to install eRepublik script, as it will always install the most recent stable release.
 
@@ -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
-.. _tarball: https://github.com/eeriks/erepublik_script/tarball/master
+.. _Github repo: https://github.com/eeriks/erepublik
+.. _tarball: https://github.com/eeriks/erepublik/tarball/master

docs/make.bat

@@ -9,7 +9,7 @@ if "%SPHINXBUILD%" == "" (
 )
 set SOURCEDIR=.
 set BUILDDIR=_build
-set SPHINXPROJ=erepublik_script
+set SPHINXPROJ=erepublik
 
 if "%1" == "" goto help
 

docs/usage.rst

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

erepublik/__init__.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+"""Top-level package for eRepublik script."""
+
+__author__ = """Eriks Karls"""
+__email__ = 'eriks@72.lv'
+__version__ = '0.20.1'
+__commit_id__ = "a825917"
+
+from erepublik import classes, utils
+from erepublik.citizen import Citizen
+
+__all__ = ["classes", "utils", "Citizen"]

erepublik/access_points.py

@@ -0,0 +1,663 @@
+import datetime
+import random
+import time
+from typing import Any, Dict, List, Mapping, Union
+
+from requests import Response, Session
+
+from erepublik import utils
+
+__all__ = ['SlowRequests', 'CitizenAPI']
+
+
+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) Chrome/81.0.4044.138 Safari/537.36',  # noqa
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36',  # noqa
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',  # noqa
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',  # noqa
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 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',
+
+        # FireFox
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:76.0) Gecko/20100101 Firefox/76.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:75.0) Gecko/20100101 Firefox/75.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:73.0) Gecko/20100101 Firefox/73.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:76.0) Gecko/20100101 Firefox/76.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:75.0) Gecko/20100101 Firefox/75.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:74.0) Gecko/20100101 Firefox/74.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:73.0) Gecko/20100101 Firefox/73.0',
+    ]
+    debug = False
+
+    def __init__(self):
+        super().__init__()
+        self.request_log_name = utils.get_file(utils.now().strftime("debug/requests_%Y-%m-%d.log"))
+        self.last_time = utils.now()
+        self.headers.update({
+            'User-Agent': random.choice(self.uas)
+        })
+
+    @property
+    def __dict__(self):
+        return dict(last_time=self.last_time, timeout=self.timeout, user_agent=self.headers['User-Agent'],
+                    request_log_name=self.request_log_name, debug=self.debug)
+
+    def request(self, method, url, *args, **kwargs):
+        self._slow_down_requests()
+        self._log_request(url, method, **kwargs)
+        resp = super().request(method, url, *args, **kwargs)
+        self._log_response(url, resp)
+        return resp
+
+    def _slow_down_requests(self):
+        ltt = utils.good_timedelta(self.last_time, self.timeout)
+        if ltt > utils.now():
+            seconds = (ltt - utils.now()).total_seconds()
+            time.sleep(seconds if seconds > 0 else 0)
+        self.last_time = utils.now()
+
+    def _log_request(self, url, method, data=None, json=None, params=None, **kwargs):
+        if self.debug:
+            args = {}
+            kwargs.pop('allow_redirects', None)
+            if kwargs:
+                args.update({'kwargs': kwargs})
+
+            if data:
+                args.update({"data": data})
+
+            if json:
+                args.update({"json": json})
+
+            if params:
+                args.update({"params": params})
+
+            body = "[{dt}]\tURL: '{url}'\tMETHOD: {met}\tARGS: {args}\n".format(dt=utils.now().strftime("%F %T"),
+                                                                                url=url, met=method, args=args)
+            utils.get_file(self.request_log_name)
+            with open(self.request_log_name, 'ab') as file:
+                file.write(body.encode("UTF-8"))
+
+    def _log_response(self, url, resp, redirect: bool = False):
+        from erepublik import Citizen
+        if self.debug:
+            if resp.history and not redirect:
+                for hist_resp in resp.history:
+                    self._log_request(hist_resp.request.url, "REDIRECT")
+                    self._log_response(hist_resp.request.url, hist_resp, redirect=True)
+
+            file_data = {
+                "path": 'debug/requests',
+                "time": self.last_time.strftime('%Y/%m/%d/%H-%M-%S'),
+                "name": utils.slugify(url[len(Citizen.url):]),
+                "extra": "_REDIRECT" if redirect else ""
+            }
+
+            try:
+                utils.json.loads(resp.text)
+                file_data.update({"ext": "json"})
+            except utils.json.JSONDecodeError:
+                file_data.update({"ext": "html"})
+
+            filename = 'debug/requests/{time}_{name}{extra}.{ext}'.format(**file_data)
+            with open(utils.get_file(filename), 'wb') as f:
+                f.write(resp.text.encode('utf-8'))
+
+
+class CitizenBaseAPI:
+    url: str = "https://www.erepublik.com/en"
+    _req: SlowRequests = None
+    token: str = ""
+
+    def __init__(self):
+        """ Class for unifying eRepublik known endpoints and their required/optional parameters """
+        self._req = SlowRequests()
+
+    def post(self, url: str, data=None, json=None, **kwargs) -> Response:
+        return self._req.post(url, data, json, **kwargs)
+
+    def get(self, url: str, **kwargs) -> Response:
+        return self._req.get(url, **kwargs)
+
+    def _get_main(self) -> Response:
+        return self.get(self.url)
+
+
+class ErepublikAnniversaryAPI(CitizenBaseAPI):
+    def _post_main_collect_anniversary_reward(self) -> Response:
+        return self.post("{}/main/collect-anniversary-reward".format(self.url), data={"_token": self.token})
+
+    # 12th anniversary endpoints
+    def _get_anniversary_quest_data(self) -> Response:
+        return self.get("{}/main/anniversaryQuestData".format(self.url))
+
+    def _post_map_rewards_unlock(self, node_id: int) -> Response:
+        data = {'nodeId': node_id, '_token': self.token}
+        return self.post("{}/main/map-rewards-unlock".format(self.url), data=data)
+
+    def _post_map_rewards_speedup(self, node_id: int, currency_amount: int) -> Response:
+        data = {'nodeId': node_id, '_token': self.token, "currencyCost": currency_amount}
+        return self.post("{}/main/map-rewards-speedup".format(self.url), data=data)
+
+    def _post_map_rewards_claim(self, node_id: int) -> Response:
+        data = {'nodeId': node_id, '_token': self.token}
+        return self.post("{}/main/map-rewards-claim".format(self.url), data=data)
+
+    def _post_main_wheel_of_fortune_spin(self, cost) -> Response:
+        return self.post(f"{self.url}/wheeloffortune-spin", data={'_token': self.token, "cost": cost})
+
+    def _post_main_wheel_of_fortune_build(self) -> Response:
+        return self.post(f"{self.url}/wheeloffortune-build", data={'_token': self.token})
+
+
+class ErepublikArticleAPI(CitizenBaseAPI):
+    def _get_main_article_json(self, article_id: int) -> Response:
+        return self.get("{}/main/articleJson/{}".format(self.url, article_id))
+
+    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_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_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_main_write_article(self, title: str, content: str, country: int, kind: int) -> Response:
+        data = dict(_token=self.token, article_name=title, article_body=content, article_location=country,
+                    article_category=kind)
+        return self.post("{}/main/write-article".format(self.url), data=data)
+
+    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)
+
+
+class ErepublikCompanyAPI(CitizenBaseAPI):
+    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:
+        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 _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:
+        return self.get("{}/economy/job-market-json/{}/1/desc".format(self.url, country))
+
+    def _get_economy_my_companies(self) -> Response:
+        return self.get("{}/economy/myCompanies".format(self.url))
+
+    def _post_economy_train(self, tg_ids: List[int]) -> Response:
+        data: Dict[str, Union[int, str]] = {}
+        for idx, tg_id in enumerate(tg_ids):
+            data["grounds[%i][id]" % idx] = tg_id
+            data["grounds[%i][train]" % idx] = 1
+        if data:
+            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:
+        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) -> Response:
+        data: Dict[str, Union[int, str]] = dict(action_type=action_type, _token=self.token)
+        if action_type == "production":
+            if employ is None:
+                employ = {}
+            if wam is None:
+                wam = []
+            max_idx = 0
+            for company_id in sorted(wam or []):
+                data.update({
+                    f"companies[{max_idx}][id]": company_id,
+                    f"companies[{max_idx}][employee_works]": employ.pop(company_id, 0),
+                    f"companies[{max_idx}][own_work]": 1
+                })
+                max_idx += 1
+            for company_id in sorted(employ or []):
+                data.update({
+                    f"companies[{max_idx}][id]": company_id,
+                    f"companies[{max_idx}][employee_works]": employ.pop(company_id, 0),
+                    f"companies[{max_idx}][own_work]": 0
+                })
+                max_idx += 1
+        return self.post("{}/economy/work".format(self.url), data=data)
+
+    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_economy_job_market_apply(self, citizen: int, salary: float) -> 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_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:
+        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("{}/economy/sell-company/{}".format(self.url, factory),
+                         data=data, headers={"Referer": self.url})
+
+
+class ErepublikCountryAPI(CitizenBaseAPI):
+    def _get_country_military(self, country: str) -> Response:
+        return self.get("{}/country/military/{}".format(self.url, country))
+
+    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)})
+
+
+class ErepublikEconomyAPI(CitizenBaseAPI):
+    def _get_economy_citizen_accounts(self, organisation_id: int) -> Response:
+        return self.get("{}/economy/citizen-accounts/{}".format(self.url, organisation_id))
+
+    def _get_economy_my_market_offers(self) -> Response:
+        return self.get("{}/economy/myMarketOffers".format(self.url))
+
+    def _get_main_job_data(self) -> Response:
+        return self.get("{}/main/job-data".format(self.url))
+
+    def _post_main_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_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_donate_items_action(self, citizen: int, amount: int, industry: int,
+                                          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,
+                                          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:
+        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:
+        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_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_marketplace(self, country: int, industry: int, quality: int,
+                                  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:
+        if buy:
+            data = dict(_token=self.token, offerId=kwargs['offer'], amount=amount, orderBy="price_asc", currentPage=1,
+                        buyAction=1)
+        else:
+            data = dict(_token=self.token, countryId=kwargs["country"], price=kwargs["price"],
+                        industryId=kwargs["industry"], quality=kwargs["quality"], amount=amount, sellAction='postOffer')
+        return self.post("{}/economy/marketplaceActions".format(self.url), data=data)
+
+
+class ErepublikLeaderBoardAPI(CitizenBaseAPI):
+    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_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_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_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))
+
+
+class ErepublikLocationAPI(CitizenBaseAPI):
+    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})
+
+
+class ErepublikMilitaryAPI(CitizenBaseAPI):
+    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_military_show_weapons(self, battle: int) -> Response:
+        return self.get("{}/military/show-weapons".format(self.url), params={'_token': self.token, 'battleId': battle})
+
+    def _get_military_campaigns(self) -> Response:
+        return self.get("{}/military/campaigns-new/".format(self.url))
+
+    def _get_military_campaigns_json_list(self) -> Response:
+        return self.get("{}/military/campaignsJson/list".format(self.url))
+
+    def _get_military_campaigns_json_citizen(self) -> Response:
+        return self.get("{}/military/campaignsJson/citizen".format(self.url))
+
+    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 _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_main_battlefield_travel(self, side_id: int, battle_id: int) -> Response:
+        data = dict(_token=self.token, sideCountryId=side_id, battleId=battle_id)
+        return self.post("{}/main/battlefieldTravel".format(self.url), data=data)
+
+    def _post_main_battlefield_change_division(self, battle_id: int, division_id: int) -> Response:
+        data = dict(_token=self.token, battleZoneId=division_id, battleId=battle_id)
+        return self.post("{}/main/battlefieldTravel".format(self.url), data=data)
+
+    def _get_wars_show(self, war_id: int) -> Response:
+        return self.get("{}/wars/show/{}".format(self.url, war_id))
+
+    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_military_change_weapon(self, battle: int, battle_zone: int, weapon_level: int, ) -> Response:
+        data = dict(battleId=battle, _token=self.token, battleZoneId=battle_zone, customizationLevel=weapon_level)
+        return self.post("{}/military/change-weapon".format(self.url), data=data)
+
+    def _post_military_battle_console(self, battle_id: int, action: str, page: int = 1, **kwargs) -> Response:
+        data = dict(battleId=battle_id, action=action, _token=self.token)
+        if action == "battleStatistics":
+            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_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, zone_id: int) -> Response:
+        data = dict(sideId=side_id, battleId=battle_id, _token=self.token, battleZoneId=zone_id)
+        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, zone_id: int) -> Response:
+        data = dict(sideId=side_id, battleId=battle_id, _token=self.token, battleZoneId=zone_id)
+        return self.post("{}/military/fight-shooot/{}".format(self.url, battle_id), data=data)
+
+    def _post_fight_deploy_deploy_report_data(self, deployment_id: int):
+        data = dict(_token=self.token, deploymentId=deployment_id)
+        return self.post(f"{self.url}/military/fightDeploy-deployReportData", json=data)
+
+
+class ErepublikPoliticsAPI(CitizenBaseAPI):
+    def _get_candidate_party(self, party_slug: str) -> Response:
+        return self.post("{}/candidate/{}".format(self.url, party_slug))
+
+    def _get_main_party_members(self, party: int) -> Response:
+        return self.get("{}/main/party-members/{}".format(self.url, party))
+
+    def _get_main_rankings_parties(self, country: int) -> Response:
+        return self.get("{}/main/rankings-parties/1/{}".format(self.url, country))
+
+    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)
+
+
+class ErepublikPresidentAPI(CitizenBaseAPI):
+    def _post_wars_attack_region(self, war_id: int, region_id: int, region_name: str) -> Response:
+        data = {'_token': self.token, 'warId': war_id, 'regionName': region_name, 'regionNameConfirm': region_name}
+        return self.post('{}/wars/attack-region/{}/{}'.format(self.url, war_id, region_id), data=data)
+
+    def _post_new_war(self, self_country_id: int, attack_country_id: int, debate: str = "") -> Response:
+        data = dict(requirments=1, _token=self.token, debate=debate,
+                    countryNameConfirm=utils.COUNTRY_LINK[attack_country_id])
+        return self.post("{}/{}/new-war".format(self.url, utils.COUNTRY_LINK[self_country_id]), data=data)
+
+    def _post_new_donation(self, country_id: int, amount: int, org_name: str, debate: str = "") -> Response:
+        data = dict(requirments=1, _token=self.token, debate=debate, currency=1, value=amount, commit='Propose',
+                    type_name=org_name)
+        return self.post("{}/{}/new-donation".format(self.url, utils.COUNTRY_LINK[country_id]), data=data)
+
+
+class ErepublikProfileAPI(CitizenBaseAPI):
+    def _get_main_citizen_hovercard(self, citizen: int) -> Response:
+        return self.get("{}/main/citizen-hovercard/{}".format(self.url, citizen))
+
+    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_main_citizen_notifications(self) -> Response:
+        return self.get("{}/main/citizenDailyAssistant".format(self.url))
+
+    def _get_main_citizen_daily_assistant(self) -> Response:
+        return self.get("{}/main/citizenNotifications".format(self.url))
+
+    def _get_main_messages_paginated(self, page: int = 1) -> Response:
+        return self.get("{}/main/messages-paginated/{}".format(self.url, page))
+
+    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_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_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_training_grounds_json(self) -> Response:
+        return self.get("{}/main/training-grounds-json".format(self.url))
+
+    def _get_main_weekly_challenge_data(self) -> Response:
+        return self.get("{}/main/weekly-challenge-data".format(self.url))
+
+    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"})
+        else:
+            data.update({"action": "removeFriend"})
+        return self.post("{}/main/citizen-addRemoveFriend".format(self.url), data=data)
+
+    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:
+        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:
+        data = dict(_token=self.token, buttonColor=color)
+        return self.post("{}/main/eat".format(self.url), params=data)
+
+    def _post_main_global_alerts_close(self, alert_id: int) -> Response:
+        data = dict(_token=self.token, alert_id=alert_id)
+        return self.post("{}/main/global-alerts/close".format(self.url), data=data)
+
+    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_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_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_main_notifications_ajax_community(self, notification_ids: List[int], page: int = 1) -> Response:
+        data = {"_token": self.token, "delete_alerts[]": notification_ids}
+        return self.post("{}/main/notificationsAjax/community/{}".format(self.url, page), data=data)
+
+    def _post_main_notifications_ajax_system(self, notification_ids: List[int], page: int = 1) -> Response:
+        data = {"_token": self.token, "delete_alerts[]": notification_ids}
+        return self.post("{}/main/notificationsAjax/system/{}".format(self.url, page), data=data)
+
+    def _post_main_notifications_ajax_report(self, notification_ids: List[int], page: int = 1) -> Response:
+        data = {"_token": self.token, "delete_alerts[]": notification_ids}
+        return self.post("{}/main/notificationsAjax/report/{}".format(self.url, page), data=data)
+
+    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)
+
+    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_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)
+
+
+class ErepublikTravelAPI(CitizenBaseAPI):
+    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_main_travel_data(self, **kwargs) -> Response:
+        return self.post("{}/main/travelData".format(self.url), data=dict(_token=self.token, **kwargs))
+
+
+class ErepublikWallPostAPI(CitizenBaseAPI):
+    # ## Country
+
+    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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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)
+
+    # ## Medal posting
+    def _post_main_wall_post_automatic(self, message: str, achievement_id: int) -> Response:
+        return self.post("{}/main/wall-post/automatic".format(self.url), data=dict(_token=self.token, message=message,
+                                                                                   achievementId=achievement_id))
+
+
+class CitizenAPI(
+    ErepublikArticleAPI, ErepublikCountryAPI, ErepublikCompanyAPI, ErepublikEconomyAPI,
+    ErepublikLeaderBoardAPI, ErepublikLocationAPI, ErepublikMilitaryAPI, ErepublikProfileAPI,
+    ErepublikPresidentAPI, ErepublikPoliticsAPI, ErepublikAnniversaryAPI, ErepublikWallPostAPI,
+    ErepublikTravelAPI
+):
+    pass

erepublik/classes.py

@@ -0,0 +1,858 @@
+import datetime
+import hashlib
+import threading
+from collections import defaultdict, deque
+from decimal import Decimal
+from typing import Any, Dict, List, NamedTuple, Tuple, Union, Optional
+
+from requests import Response, Session, post
+
+from erepublik import utils
+from erepublik.utils import json
+
+INDUSTRIES = {1: "Food", 2: "Weapons", 4: "House", 23: "Aircraft",
+              7: "FRM q1", 8: "FRM q2", 9: "FRM q3", 10: "FRM q4", 11: "FRM q5",
+              12: "WRM q1", 13: "WRM q2", 14: "WRM q3", 15: "WRM q4", 16: "WRM q5",
+              18: "HRM q1", 19: "HRM q2", 20: "HRM q3", 21: "HRM q4", 22: "HRM q5",
+              24: "ARM q1", 25: "ARM q2", 26: "ARM q3", 27: "ARM q4", 28: "ARM q5", }
+
+
+class ErepublikException(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class ErepublikNetworkException(ErepublikException):
+    def __init__(self, message, request):
+        super().__init__(message)
+        self.request = request
+
+
+class Holding:
+    id: int
+    region: int
+    companies: List["Company"]
+
+    def __init__(self, _id: int, region: int):
+        self.id: int = _id
+        self.region: int = region
+        self.companies: List["Company"] = list()
+
+    @property
+    def wam_count(self) -> int:
+        return sum([company.wam_enabled and not company.already_worked for company in self.companies])
+
+    @property
+    def wam_companies(self) -> List["Company"]:
+        return [company for company in self.companies if company.wam_enabled]
+
+    @property
+    def employable_companies(self) -> List["Company"]:
+        return [company for company in self.companies if company.preset_works]
+
+    def add_company(self, company: "Company"):
+        self.companies.append(company)
+        self.companies.sort()
+
+    def get_wam_raw_usage(self) -> Dict[str, Decimal]:
+        frm = Decimal("0.00")
+        wrm = Decimal("0.00")
+        for company in self.wam_companies:
+            if company.industry in [1, 7, 8, 9, 10, 11]:
+                frm += company.raw_usage
+            elif company.industry in [2, 12, 13, 14, 15, 16]:
+                wrm += company.raw_usage
+        return dict(frm=frm, wrm=wrm)
+
+    def __str__(self):
+        return f"Holding (#{self.id}) with {len(self.companies)} compan{'y' if len(self.companies) % 10 == 1 else 'ies'}"
+
+    def __repr__(self):
+        return str(self)
+
+
+class Company:
+    holding: Holding
+    id: int
+    quality: int
+    is_raw: bool
+    raw_usage: Decimal
+    products_made: Decimal
+    wam_enabled: bool
+    can_wam: bool
+    cannot_wam_reason: str
+    industry: int
+    already_worked: bool
+    preset_works: int
+
+    def __init__(
+        self, holding: Holding, _id: int, quality: int, is_raw: bool, effective_bonus: Decimal, raw_usage: Decimal,
+        base_production: Decimal, wam_enabled: bool, can_wam: bool, cannot_wam_reason: str, industry: int,
+        already_worked: bool, preset_works: int
+    ):
+        self.holding: Holding = holding
+        self.id: int = _id
+        self.industry: int = industry
+        self.quality: int = self._get_real_quality(quality)
+        self.is_raw: bool = is_raw
+        self.wam_enabled: bool = wam_enabled
+        self.can_wam: bool = can_wam
+        self.cannot_wam_reason: str = cannot_wam_reason
+        self.already_worked: bool = already_worked
+        self.preset_works: int = preset_works
+
+        self.products_made = self.raw_usage = Decimal(base_production) * Decimal(effective_bonus)
+        if not self.is_raw:
+            self.raw_usage = - self.products_made * raw_usage
+
+    def _get_real_quality(self, quality) -> int:
+        #  7: "FRM q1",  8: "FRM q2",  9: "FRM q3", 10: "FRM q4", 11: "FRM q5",
+        # 12: "WRM q1", 13: "WRM q2", 14: "WRM q3", 15: "WRM q4", 16: "WRM q5",
+        # 18: "HRM q1", 19: "HRM q2", 20: "HRM q3", 21: "HRM q4", 22: "HRM q5",
+        # 24: "ARM q1", 25: "ARM q2", 26: "ARM q3", 27: "ARM q4", 28: "ARM q5",
+        if 7 <= self.industry <= 11:
+            return self.industry % 6
+        elif 12 <= self.industry <= 16:
+            return self.industry % 11
+        elif 18 <= self.industry <= 22:
+            return self.industry % 17
+        elif 24 <= self.industry <= 28:
+            return self.industry % 23
+        else:
+            return quality
+
+    @property
+    def _internal_industry(self) -> int:
+        #  7: "FRM q1",  8: "FRM q2",  9: "FRM q3", 10: "FRM q4", 11: "FRM q5",
+        # 12: "WRM q1", 13: "WRM q2", 14: "WRM q3", 15: "WRM q4", 16: "WRM q5",
+        # 18: "HRM q1", 19: "HRM q2", 20: "HRM q3", 21: "HRM q4", 22: "HRM q5",
+        # 24: "ARM q1", 25: "ARM q2", 26: "ARM q3", 27: "ARM q4", 28: "ARM q5",
+        if 7 <= self.industry <= 11:
+            return 7
+        elif 12 <= self.industry <= 16:
+            return 12
+        elif 18 <= self.industry <= 22:
+            return 18
+        elif 24 <= self.industry <= 28:
+            return 24
+        else:
+            return self.industry
+
+    @property
+    def _sort_keys(self):
+        return not self.is_raw, self._internal_industry, -self.quality, self.id
+
+    def __hash__(self):
+        return hash(self._sort_keys)
+
+    def __lt__(self, other: "Company"):
+        return self._sort_keys < other._sort_keys
+
+    def __le__(self, other: "Company"):
+        return self._sort_keys <= other._sort_keys
+
+    def __gt__(self, other: "Company"):
+        return self._sort_keys > other._sort_keys
+
+    def __ge__(self, other: "Company"):
+        return self._sort_keys >= other._sort_keys
+
+    def __eq__(self, other: "Company"):
+        return self._sort_keys == other._sort_keys
+
+    def __ne__(self, other: "Company"):
+        return self._sort_keys != other._sort_keys
+
+    def __str__(self):
+        name = f"(#{self.id:>9d}) {INDUSTRIES[self.industry]}"
+        if not self.is_raw:
+            name += f" q{self.quality}"
+        return name
+
+    def __repr__(self):
+        return str(self)
+
+
+class MyCompanies:
+    work_units: int = 0
+    next_ot_time: datetime.datetime
+    ff_lockdown: int = 0
+
+    holdings: Dict[int, Holding]
+    companies: List[Company]
+
+    def __init__(self):
+        self.holdings: Dict[int, Holding] = dict()
+        self.companies: List[Company] = list()
+        self.next_ot_time = utils.now()
+
+    def prepare_holdings(self, holdings: Dict[str, Dict[str, Any]]):
+        """
+        :param holdings: Parsed JSON to dict from en/economy/myCompanies
+        """
+        for holding in holdings.values():
+            if holding.get('id') not in self.holdings:
+                self.holdings.update({int(holding.get('id')): Holding(holding['id'], holding['region_id'])})
+        if not self.holdings.get(0):
+            self.holdings.update({0: Holding(0, 0)})  # unassigned
+
+    def prepare_companies(self, companies: Dict[str, Dict[str, Any]]):
+        """
+        :param companies: Parsed JSON to dict from en/economy/myCompanies
+        """
+        self.__clear_data()
+        for company_dict in companies.values():
+            holding = self.holdings.get(int(company_dict['holding_company_id']))
+            quality = company_dict.get('quality')
+            is_raw = company_dict.get('is_raw')
+            if is_raw:
+                raw_usage = Decimal('0.0')
+            else:
+                raw_usage = Decimal(str(company_dict.get('upgrades').get(str(quality)).get('raw_usage')))
+            company = Company(
+                holding, company_dict.get('id'), quality, is_raw,
+                Decimal(str(company_dict.get('effective_bonus'))) / 100,
+                raw_usage, Decimal(str(company_dict.get('base_production'))), company_dict.get('wam_enabled'),
+                company_dict.get('can_work_as_manager'), company_dict.get('cannot_work_as_manager_reason'),
+                company_dict.get('industry_id'), company_dict.get('already_worked'), company_dict.get('preset_works')
+            )
+            self.companies.append(company)
+            holding.add_company(company)
+
+    def get_employable_factories(self) -> Dict[int, int]:
+        return {company.id: company.preset_works for company in self.companies if company.preset_works}
+
+    def get_total_wam_count(self) -> int:
+        return sum([holding.wam_count for holding in self.holdings.values()])
+
+    def get_holding_wam_count(self, holding_id: int, raw_factory=None) -> int:
+        """
+        Returns amount of wam enabled companies in the holding
+        :param holding_id: holding id
+        :param raw_factory: True - only raw, False - only factories, None - both
+        :return: int
+        """
+        return len(self.get_holding_wam_companies(holding_id, raw_factory))
+
+    def get_holding_wam_companies(self, holding_id: int, raw_factory: bool = None) -> List[Company]:
+        """
+        Returns WAM enabled companies in the holding, True - only raw, False - only factories, None - both
+        :param holding_id: holding id
+        :param raw_factory: bool or None
+        :return: list
+        """
+        raw = []
+        factory = []
+        if holding_id in self.holdings:
+            for company in self.holdings[holding_id].wam_companies:
+                if not company.already_worked and not company.cannot_wam_reason == "war":
+                    if company.is_raw:
+                        raw.append(company)
+                    else:
+                        factory.append(company)
+        if raw_factory is not None and not raw_factory:
+            return factory
+        elif raw_factory is not None and raw_factory:
+            return raw
+        elif raw_factory is None:
+            return raw + factory
+        else:
+            raise ErepublikException("raw_factory should be True/False/None")
+
+    @staticmethod
+    def get_needed_inventory_usage(companies: Union[Company, List[Company]]) -> Decimal:
+
+        if isinstance(companies, list):
+            return sum([company.products_made * 100 if company.is_raw else 1 for company in companies])
+        else:
+            return companies.products_made
+
+    def __str__(self):
+        return f"MyCompanies: {len(self.companies)} companies in {len(self.holdings)} holdings"
+
+    def __repr__(self):
+        return str(self)
+
+    def __clear_data(self):
+        for holding in self.holdings.values():
+            holding.companies.clear()
+        self.companies.clear()
+
+
+class Config:
+    email = ""
+    password = ""
+    work = True
+    train = True
+    wam = False
+    ot = True
+    auto_sell: List[str] = None
+    auto_sell_all = False
+    employees = False
+    fight = False
+    air = False
+    ground = False
+    all_in = False
+    next_energy = False
+    boosters = False
+    travel_to_fight = False
+    always_travel = False
+    epic_hunt = False
+    epic_hunt_ebs = False
+    rw_def_side = False
+    interactive = True
+    continuous_fighting = False
+    auto_buy_raw = False
+    force_wam = False
+    sort_battles_time = True
+    force_travel = False
+    telegram = True
+    telegram_chat_id = 0
+    telegram_token = ""
+
+    def __init__(self):
+        self.auto_sell = []
+
+    def reset(self):
+        self.work = True
+        self.train = True
+        self.wam = False
+        self.ot = True
+        self.auto_sell = list()
+        self.auto_sell_all = False
+        self.employees = False
+        self.fight = False
+        self.air = False
+        self.ground = False
+        self.all_in = False
+        self.next_energy = False
+        self.boosters = False
+        self.travel_to_fight = False
+        self.always_travel = False
+        self.epic_hunt = False
+        self.epic_hunt_ebs = False
+        self.rw_def_side = False
+        self.interactive = True
+        self.continuous_fighting = False
+        self.auto_buy_raw = False
+        self.force_wam = False
+        self.sort_battles_time = True
+        self.force_travel = False
+        self.telegram = True
+        self.telegram_chat_id = 0
+        self.telegram_token = ""
+
+    @property
+    def __dict__(self):
+        return dict(email=self.email, work=self.work, train=self.train, wam=self.wam, ot=self.ot,
+                    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,
+                    always_travel=self.always_travel, 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,
+                    telegram=self.telegram, telegram_chat_id=self.telegram_chat_id, telegram_token=self.telegram_token)
+
+
+class Energy:
+    limit = 500  # energyToRecover
+    interval = 10  # energyPerInterval
+    recoverable = 0  # energyFromFoodRemaining
+    recovered = 0  # energy
+    _recovery_time = None
+
+    def __init__(self):
+        self._recovery_time = utils.now()
+
+    def __repr__(self):
+        return "{:4}/{:4} + {:4}, {:3}hp/6min".format(self.recovered, self.limit, self.recoverable, self.interval)
+
+    def set_reference_time(self, recovery_time: datetime.datetime):
+        self._recovery_time = recovery_time.replace(microsecond=0)
+
+    @property
+    def food_fights(self):
+        return self.available // 10
+
+    @property
+    def reference_time(self):
+        if self.is_recovered_full or self._recovery_time < utils.now():
+            ret = utils.now()
+        else:
+            ret = self._recovery_time
+        return ret
+
+    @property
+    def is_recoverable_full(self):
+        return self.recoverable >= self.limit - 5 * self.interval
+
+    @property
+    def is_recovered_full(self):
+        return self.recovered >= self.limit - self.interval
+
+    @property
+    def is_energy_full(self):
+        return self.is_recoverable_full and self.is_recovered_full
+
+    @property
+    def available(self):
+        return self.recovered + self.recoverable
+
+
+class Details:
+    xp = 0
+    cc = 0
+    pp = 0
+    pin = None
+    gold = 0
+    next_pp: List[int] = None
+    citizen_id = 0
+    citizenship = 0
+    current_region = 0
+    current_country = 0
+    residence_region = 0
+    residence_country = 0
+    daily_task_done = False
+    daily_task_reward = False
+    mayhem_skills = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, }
+
+    def __init__(self):
+        self.next_pp = []
+
+    @property
+    def xp_till_level_up(self):
+        if self.xp >= 10000:
+            next_level_up = (1 + (self.xp // 5000)) * 5000
+        elif self.xp >= 7000:
+            next_level_up = 10000
+        elif self.xp >= 3000:
+            next_level_up = (1 + ((self.xp - 1000) // 2000)) * 2000 + 1000
+        elif self.xp >= 2000:
+            next_level_up = 3000
+        elif self.xp >= 450:
+            next_level_up = (1 + (self.xp // 500)) * 500
+        elif self.xp >= 370:
+            next_level_up = (1 + ((self.xp - 10) // 40)) * 40 + 10
+        elif self.xp >= 300:
+            next_level_up = (1 + ((self.xp - 20) // 35)) * 35 + 20
+        elif self.xp >= 150:
+            next_level_up = (1 + (self.xp // 30)) * 30
+        elif self.xp >= 50:
+            next_level_up = (1 + ((self.xp - 10) // 20)) * 20 + 10
+        elif self.xp >= 20:
+            next_level_up = (1 + ((self.xp - 5) // 15)) * 15 + 5
+        else:
+            next_level_up = (1 + (self.xp // 10)) * 10
+        return next_level_up - self.xp
+
+
+class Politics:
+    is_party_member: bool = False
+
+    party_id: int = 0
+    party_slug: str = ""
+    is_party_president: bool = False
+    is_congressman: bool = False
+    is_country_president: bool = False
+
+
+class House:
+    quality = None
+    unactivated_count = 0
+    active_until = utils.good_timedelta(utils.now(), -datetime.timedelta(days=1))
+
+    def __init__(self, quality: int):
+        if 0 < quality < 6:
+            self.quality = quality
+
+    @property
+    def next_ot_point(self) -> datetime.datetime:
+        return self.active_until
+
+
+class Reporter:
+    __to_update: List[Dict[Any, Any]] = None
+    name: str = ""
+    email: str = ""
+    citizen_id: int = 0
+    key: str = ""
+    allowed: bool = False
+
+    @property
+    def __dict__(self):
+        return dict(name=self.name, email=self.email, citizen_id=self.citizen_id, key=self.key, allowed=self.allowed,
+                    queue=self.__to_update)
+
+    def __init__(self):
+        self._req = Session()
+        self.url = "https://api.erep.lv"
+        self._req.headers.update({"user-agent": "Bot reporter v2"})
+        self.__to_update = []
+        self.__registered: bool = False
+
+    def do_init(self, name: str = "", email: str = "", citizen_id: int = 0):
+        self.name: str = name
+        self.email: str = email
+        self.citizen_id: int = citizen_id
+        self.key: str = ""
+        self.__update_key()
+        self.register_account()
+        self.allowed = True
+
+    def __update_key(self):
+        self.key = hashlib.md5(bytes(f"{self.name}:{self.email}", encoding="UTF-8")).hexdigest()
+
+    def __bot_update(self, data: dict) -> Response:
+        if self.__to_update:
+            for unreported_data in self.__to_update:
+                unreported_data.update(player_id=self.citizen_id, key=self.key)
+                self._req.post("{}/bot/update".format(self.url), json=unreported_data)
+            self.__to_update.clear()
+        r = self._req.post("{}/bot/update".format(self.url), json=data)
+        return r
+
+    def register_account(self):
+        if not self.__registered:
+            try:
+                r = self.__bot_update(dict(key=self.key, check=True, player_id=self.citizen_id))
+                if not r.json().get("status"):
+                    self._req.post("{}/bot/register".format(self.url), json=dict(name=self.name, email=self.email,
+                                                                                 player_id=self.citizen_id))
+            finally:
+                self.__registered = True
+                self.allowed = True
+                self.report_action("STARTED", value=utils.now().strftime("%F %T"))
+
+    def send_state_update(self, xp: int, cc: float, gold: float, inv_total: int, inv: int,
+                          hp_limit: int, hp_interval: int, hp_available: int, food: int, pp: int):
+
+        data = dict(key=self.key, player_id=self.citizen_id, state=dict(
+            xp=xp, cc=cc, gold=gold, inv_total=inv_total, inv_free=inv_total - inv, inv=inv, food=food,
+            pp=pp, hp_limit=hp_limit, hp_interval=hp_interval, hp_available=hp_available,
+        ))
+
+        if self.allowed:
+            self.__bot_update(data)
+
+    def report_action(self, action: str, json_val: Dict[Any, Any] = None, value: str = None):
+        json_data = dict(
+            player_id=getattr(self, 'citizen_id', None), log={'action': action}, key=getattr(self, 'key', None)
+        )
+        if json_val:
+            json_data['log'].update(dict(json=json_val))
+        if value:
+            json_data['log'].update(dict(value=value))
+        if not any([self.key, self.email, self.name, self.citizen_id]):
+            return
+        if self.allowed:
+            self.__bot_update(json_data)
+        else:
+            self.__to_update.append(json_data)
+
+    def report_promo(self, kind: str, time_until: datetime.datetime):
+        self._req.post(f"{self.url}/promos/add/", data=dict(kind=kind, time_untill=time_until))
+
+    def fetch_battle_priorities(self, country_id: int) -> List[int]:
+        try:
+            battle_response = self._req.get(f'{self.url}/api/v1/battles/{country_id}')
+            return battle_response.json().get('battle_ids', [])
+        except:  # noqa
+            return []
+
+    def fetch_tasks(self) -> Optional[Tuple[str, Tuple[Any]]]:
+        try:
+            task_response = self._req.get(f'{self.url}/api/v1/command',
+                                          params=dict(citizen=self.citizen_id, key=self.key))
+            return task_response.json().get('task_collection')
+        except:  # noqa
+            return
+
+
+class MyJSONEncoder(json.JSONEncoder):
+    def default(self, o):
+        from erepublik.citizen import Citizen
+        if isinstance(o, Decimal):
+            return float(f"{o:.02f}")
+        elif isinstance(o, datetime.datetime):
+            return dict(__type__='datetime', date=o.strftime("%Y-%m-%d"), time=o.strftime("%H:%M:%S"),
+                        tzinfo=o.tzinfo.tzname if o.tzinfo else None)
+        elif isinstance(o, datetime.date):
+            return dict(__type__='date', date=o.strftime("%Y-%m-%d"))
+        elif isinstance(o, datetime.timedelta):
+            return dict(__type__='timedelta', days=o.days, seconds=o.seconds,
+                        microseconds=o.microseconds, total_seconds=o.total_seconds())
+        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, set)):
+            return list(o)
+        elif isinstance(o, Citizen):
+            return o.to_json()
+        try:
+            return super().default(o)
+        except TypeError as e:
+            name = None
+            for ___, ____ in globals().copy().items():
+                if id(o) == id(____):
+                    name = ___
+            return dict(__error__=str(e), __type__=str(type(o)), __name__=name)
+
+
+class BattleSide:
+    id: int
+    points: int
+    deployed: List[int] = None
+    allies: List[int] = None
+
+    def __init__(self, country_id: int, points: int, allies: List[int], deployed: List[int]):
+        self.id = country_id
+        self.points = points
+        self.allies = [int(ally) for ally in allies]
+        self.deployed = [int(ally) for ally in deployed]
+
+
+class BattleDivision:
+    end: datetime.datetime
+    epic: bool
+    dom_pts: Dict[str, int]
+    wall: Dict[str, Union[int, float]]
+    battle_zone_id: int
+    def_medal: Dict[str, int]
+    inv_medal: Dict[str, int]
+
+    @property
+    def div_end(self) -> bool:
+        return utils.now() >= self.end
+
+    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:
+    id: int
+    war_id: int
+    zone_id: int
+    is_rw: bool
+    is_dict_lib: bool
+    start: datetime.datetime
+    invader: BattleSide
+    defender: BattleSide
+    div: Dict[int, BattleDivision]
+
+    @property
+    def is_air(self) -> bool:
+        return not bool(self.zone_id % 4)
+
+    def __init__(self, battle: Dict[str, Any]):
+        """Object representing eRepublik battle.
+
+        :param battle: Dict object for single battle from '/military/campaignsJson/list' response's 'battles' object
+        """
+
+        self.id = int(battle.get('id'))
+        self.war_id = int(battle.get('war_id'))
+        self.zone_id = int(battle.get('zone_id'))
+        self.is_rw = bool(battle.get('is_rw'))
+        self.is_as = bool(battle.get('is_as'))
+        self.is_dict_lib = bool(battle.get('is_dict')) or bool(battle.get('is_lib'))
+        self.start = datetime.datetime.fromtimestamp(int(battle.get('start', 0)), tz=utils.erep_tz)
+
+        self.invader = BattleSide(
+            battle.get('inv', {}).get('id'), battle.get('inv', {}).get('points'),
+            [row.get('id') for row in battle.get('inv', {}).get('ally_list')],
+            [row.get('id') for row in battle.get('inv', {}).get('ally_list') if row['deployed']]
+        )
+
+        self.defender = BattleSide(
+            battle.get('def', {}).get('id'), battle.get('def', {}).get('points'),
+            [row.get('id') for row in battle.get('def', {}).get('ally_list')],
+            [row.get('id') for row in battle.get('def', {}).get('ally_list') if row['deployed']]
+        )
+
+        self.div = defaultdict(BattleDivision)
+        for div, data in battle.get('div', {}).items():
+            div = int(data.get('div'))
+            if data.get('end'):
+                end = datetime.datetime.fromtimestamp(data.get('end'), tz=utils.erep_tz)
+            else:
+                end = utils.localize_dt(datetime.datetime.max - datetime.timedelta(days=1))
+
+            if not data['stats']['def']:
+                def_medal = (0, 0)
+            else:
+                def_medal = (data['stats']['def']['citizenId'], data['stats']['def']['damage'])
+            if not data['stats']['inv']:
+                inv_medal = (0, 0)
+            else:
+                inv_medal = (data['stats']['inv']['citizenId'], data['stats']['inv']['damage'])
+            battle_div = BattleDivision(end=end, epic=data.get('epic_type') in [1, 5], div_id=data.get('id'),
+                                        inv_pts=data.get('dom_pts').get("inv"), def_pts=data.get('dom_pts').get("def"),
+                                        wall_for=data.get('wall').get("for"), wall_dom=data.get('wall').get("dom"),
+                                        def_medal=def_medal, inv_medal=inv_medal)
+
+            self.div.update({div: battle_div})
+
+    def __repr__(self):
+        now = utils.now()
+        is_started = self.start < utils.now()
+        if is_started:
+            time_part = " {}".format(now - self.start)
+        else:
+            time_part = "-{}".format(self.start - now)
+
+        return f"Battle {self.id} | " \
+               f"{utils.ISO_CC[self.invader.id]} : {utils.ISO_CC[self.defender.id]} | " \
+               f"Round {self.zone_id:2} | " \
+               f"Round time {time_part}"
+
+
+class EnergyToFight:
+    energy: int = 0
+
+    def __init__(self, energy: int = 0):
+        self.energy = energy
+
+    def __int__(self):
+        return self.energy
+
+    def __str__(self):
+        return str(self.energy)
+
+    def __repr__(self):
+        return str(self.energy)
+
+    @property
+    def i(self):
+        return self.__int__()
+
+    @property
+    def s(self):
+        return self.__str__()
+
+    def check(self, new_energy: int):
+        if not isinstance(new_energy, (tuple, int)):
+            return self.energy
+        if 0 < new_energy < self.energy:
+            self.energy = new_energy
+        return self.energy
+
+
+class TelegramBot:
+    __initialized: bool = False
+    __queue: List[str]
+    chat_id: int = 0
+    api_url: str = ""
+    player_name: str = ""
+    __thread_stopper: threading.Event
+    _last_time: datetime.datetime
+    _last_full_energy_report: datetime.datetime
+    _next_time: datetime.datetime
+    _threads: List[threading.Thread]
+
+    def __init__(self, stop_event: threading.Event = None):
+        self._threads = []
+        self.__queue = []
+        self.__thread_stopper = threading.Event() if stop_event is None else stop_event
+        self._last_full_energy_report = self._last_time = utils.good_timedelta(utils.now(), datetime.timedelta(hours=1))
+        self._next_time = utils.now()
+
+    @property
+    def __dict__(self):
+        return {'chat_id': self.chat_id, 'api_url': self.api_url, 'player': self.player_name,
+                'last_time': self._last_time, 'next_time': self._next_time, 'queue': self.__queue,
+                'initialized': self.__initialized, 'has_threads': bool(len(self._threads))}
+
+    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))
+        self._last_full_energy_report = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-30))
+        if self.__queue:
+            self.send_message("\n\n––––––––––––––––––––––\n\n".join(self.__queue))
+
+    def send_message(self, message: str) -> bool:
+        self.__queue.append(message)
+        if not self.__initialized:
+            if self._last_time < utils.now():
+                self.__queue.clear()
+            return True
+        self._threads = [t for t in self._threads if t.is_alive()]
+        self._next_time = utils.good_timedelta(utils.now(), datetime.timedelta(seconds=20))
+        if not self._threads:
+            name = "telegram_{}send".format(f"{self.player_name}_" if self.player_name else "")
+            send_thread = threading.Thread(target=self.__send_messages, name=name)
+            send_thread.start()
+            self._threads.append(send_thread)
+
+        return True
+
+    def report_free_bhs(self, battles: List[Tuple[int, int, int, int, datetime.timedelta]]):
+        battle_links = []
+        for battle_id, side_id, against_id, damage, time_left in battles:
+            total_seconds = int(time_left.total_seconds())
+            time_start = ""
+            hours, remainder = divmod(total_seconds, 3600)
+            if hours:
+                time_start = f"{hours}h "
+            minutes, seconds = divmod(remainder, 60)
+            time_start += f"{minutes:02}m {seconds:02}s"
+            damage = "{:,}".format(damage).replace(',', ' ')
+            battle_links.append(f"*{damage}*dmg bh for [{utils.COUNTRIES[side_id]} vs {utils.COUNTRIES[against_id]}]"
+                                f"(https://www.erepublik.com/en/military/battlefield/{battle_id}) "
+                                f"_time since start {time_start}_")
+        self.send_message("Free BHs:\n" + "\n".join(battle_links))
+
+    def report_full_energy(self, available: int, limit: int, interval: int):
+        if (utils.now() - self._last_full_energy_report).total_seconds() >= 30 * 60:
+            self._last_full_energy_report = utils.now()
+            message = f"Full energy ({available}hp/{limit}hp +{interval}hp/6min)"
+            self.send_message(message)
+
+    def report_medal(self, msg, multiple: bool = True):
+        new_line = '\n' if multiple else ''
+        self.send_message(f"New award: {new_line}*{msg}*")
+
+    def __send_messages(self):
+        while self._next_time > utils.now():
+            if self.__thread_stopper.is_set():
+                break
+            self.__thread_stopper.wait(utils.get_sleep_seconds(self._next_time))
+
+        message = "\n\n––––––––––––––––––––––\n\n".join(self.__queue)
+        if self.player_name:
+            message = f"Player *{self.player_name}*\n" + message
+        response = post(self.api_url, json=dict(chat_id=self.chat_id, text=message, parse_mode="Markdown"))
+        self._last_time = utils.now()
+        if response.json().get('ok'):
+            self.__queue.clear()
+            return True
+        return False
+
+
+class OfferItem(NamedTuple):
+    price: float = 99_999.
+    country: int = 0
+    amount: int = 0
+    offer_id: int = 0
+    citizen_id: int = 0

erepublik/utils.py

@@ -0,0 +1,462 @@
+import datetime
+import inspect
+import os
+import re
+import sys
+import textwrap
+import time
+import traceback
+import unicodedata
+from decimal import Decimal
+from pathlib import Path
+from typing import Any, List, Mapping, Optional, Union, Dict
+
+import pytz
+import requests
+
+from . import __commit_id__, __version__
+
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
+__all__ = ["FOOD_ENERGY", "COMMIT_ID", "COUNTRIES", "erep_tz", 'COUNTRY_LINK',
+           "now", "localize_dt", "localize_timestamp", "good_timedelta", "eday_from_date", "date_from_eday",
+           "get_sleep_seconds", "interactive_sleep", "silent_sleep",
+           "write_silent_log", "write_interactive_log", "get_file", "write_file",
+           "send_email", "normalize_html_json", "process_error", "process_warning",
+           'calculate_hit', 'get_ground_hit_dmg_value', 'get_air_hit_dmg_value']
+
+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[str, int] = dict(q1=2, q2=4, q3=6, q4=8, q5=10, q6=12, q7=20)
+COMMIT_ID: str = __commit_id__
+VERSION: str = __version__
+
+erep_tz = pytz.timezone('US/Pacific')
+AIR_RANKS: Dict[int, str] = {
+    1: "Airman", 2: "Airman 1st Class", 3: "Airman 1st Class*", 4: "Airman 1st Class**", 5: "Airman 1st Class***",
+    6: "Airman 1st Class****", 7: "Airman 1st Class*****", 8: "Senior Airman", 9: "Senior Airman*",
+    10: "Senior Airman**", 11: "Senior Airman***", 12: "Senior Airman****", 13: "Senior Airman*****",
+    14: "Staff Sergeant", 15: "Staff Sergeant*", 16: "Staff Sergeant**", 17: "Staff Sergeant***",
+    18: "Staff Sergeant****", 19: "Staff Sergeant*****", 20: "Aviator", 21: "Aviator*", 22: "Aviator**",
+    23: "Aviator***", 24: "Aviator****", 25: "Aviator*****", 26: "Flight Lieutenant", 27: "Flight Lieutenant*",
+    28: "Flight Lieutenant**", 29: "Flight Lieutenant***", 30: "Flight Lieutenant****", 31: "Flight Lieutenant*****",
+    32: "Squadron Leader", 33: "Squadron Leader*", 34: "Squadron Leader**", 35: "Squadron Leader***",
+    36: "Squadron Leader****", 37: "Squadron Leader*****", 38: "Chief Master Sergeant", 39: "Chief Master Sergeant*",
+    40: "Chief Master Sergeant**", 41: "Chief Master Sergeant***", 42: "Chief Master Sergeant****",
+    43: "Chief Master Sergeant*****", 44: "Wing Commander", 45: "Wing Commander*", 46: "Wing Commander**",
+    47: "Wing Commander***", 48: "Wing Commander****", 49: "Wing Commander*****", 50: "Group Captain",
+    51: "Group Captain*", 52: "Group Captain**", 53: "Group Captain***", 54: "Group Captain****",
+    55: "Group Captain*****", 56: "Air Commodore", 57: "Air Commodore*", 58: "Air Commodore**", 59: "Air Commodore***",
+    60: "Air Commodore****", 61: "Air Commodore*****",
+}
+
+GROUND_RANKS: Dict[int, str] = {
+    1: "Recruit", 2: "Private", 3: "Private*", 4: "Private**", 5: "Private***",
+    6: "Corporal", 7: "Corporal*", 8: "Corporal**", 9: "Corporal***",
+    10: "Sergeant", 11: "Sergeant*", 12: "Sergeant**", 13: "Sergeant***",
+    14: "Lieutenant", 15: "Lieutenant*", 16: "Lieutenant**", 17: "Lieutenant***",
+    18: "Captain", 19: "Captain*", 20: "Captain**", 21: "Captain***",
+    22: "Major", 23: "Major*", 24: "Major**", 25: "Major***",
+    26: "Commander", 27: "Commander*", 28: "Commander**", 29: "Commander***",
+    30: "Lt Colonel", 31: "Lt Colonel*", 32: "Lt Colonel**", 33: "Lt Colonel***",
+    34: "Colonel", 35: "Colonel*", 36: "Colonel**", 37: "Colonel***",
+    38: "General", 39: "General*", 40: "General**", 41: "General***",
+    42: "Field Marshal", 43: "Field Marshal*", 44: "Field Marshal**", 45: "Field Marshal***",
+    46: "Supreme Marshal", 47: "Supreme Marshal*", 48: "Supreme Marshal**", 49: "Supreme Marshal***",
+    50: "National Force", 51: "National Force*", 52: "National Force**", 53: "National Force***",
+    54: "World Class Force", 55: "World Class Force*", 56: "World Class Force**", 57: "World Class Force***",
+    58: "Legendary Force", 59: "Legendary Force*", 60: "Legendary Force**", 61: "Legendary Force***",
+    62: "God of War", 63: "God of War*", 64: "God of War**", 65: "God of War***",
+    66: "Titan", 67: "Titan*", 68: "Titan**", 69: "Titan***",
+    70: "Legends I", 71: "Legends II", 72: "Legends III", 73: "Legends IV", 74: "Legends V", 75: "Legends VI",
+    76: "Legends VII", 77: "Legends VIII", 78: "Legends IX", 79: "Legends X", 80: "Legends XI", 81: "Legends XII",
+    82: "Legends XIII", 83: "Legends XIV", 84: "Legends XV", 85: "Legends XVI", 86: "Legends XVII", 87: "Legends XVIII",
+    88: "Legends XIX", 89: "Legends XX",
+}
+
+GROUND_RANK_POINTS: Dict[int, int] = {
+    1: 0, 2: 15, 3: 45, 4: 80, 5: 120, 6: 170, 7: 250, 8: 350, 9: 450, 10: 600, 11: 800, 12: 1000,
+    13: 1400, 14: 1850, 15: 2350, 16: 3000, 17: 3750, 18: 5000, 19: 6500, 20: 9000, 21: 12000,
+    22: 15500, 23: 20000, 24: 25000, 25: 31000, 26: 40000, 27: 52000, 28: 67000, 29: 85000,
+    30: 110000, 31: 140000, 32: 180000, 33: 225000, 34: 285000, 35: 355000, 36: 435000, 37: 540000,
+    38: 660000, 39: 800000, 40: 950000, 41: 1140000, 42: 1350000, 43: 1600000, 44: 1875000,
+    45: 2185000, 46: 2550000, 47: 3000000, 48: 3500000, 49: 4150000, 50: 4900000, 51: 5800000,
+    52: 7000000, 53: 9000000, 54: 11500000, 55: 14500000, 56: 18000000, 57: 22000000, 58: 26500000,
+    59: 31500000, 60: 37000000, 61: 43000000, 62: 50000000, 63: 100000000, 64: 200000000,
+    65: 500000000, 66: 1000000000, 67: 2000000000, 68: 4000000000, 69: 10000000000, 70: 20000000000,
+    71: 30000000000, 72: 40000000000, 73: 50000000000, 74: 60000000000, 75: 70000000000,
+    76: 80000000000, 77: 90000000000, 78: 100000000000, 79: 110000000000, 80: 120000000000,
+    81: 130000000000, 82: 140000000000, 83: 150000000000, 84: 160000000000, 85: 170000000000,
+    86: 180000000000, 87: 190000000000, 88: 200000000000, 89: 210000000000
+}
+
+COUNTRIES: Dict[int, str] = {
+    1: 'Romania', 9: 'Brazil', 10: 'Italy', 11: 'France', 12: 'Germany', 13: 'Hungary', 14: 'China', 15: 'Spain',
+    23: 'Canada', 24: 'USA', 26: 'Mexico', 27: 'Argentina', 28: 'Venezuela', 29: 'United Kingdom', 30: 'Switzerland',
+    31: 'Netherlands', 32: 'Belgium', 33: 'Austria', 34: 'Czech Republic', 35: 'Poland', 36: 'Slovakia', 37: 'Norway',
+    38: 'Sweden', 39: 'Finland', 40: 'Ukraine', 41: 'Russia', 42: 'Bulgaria', 43: 'Turkey', 44: 'Greece', 45: 'Japan',
+    47: 'South Korea', 48: 'India', 49: 'Indonesia', 50: 'Australia', 51: 'South Africa', 52: 'Republic of Moldova',
+    53: 'Portugal', 54: 'Ireland', 55: 'Denmark', 56: 'Iran', 57: 'Pakistan', 58: 'Israel', 59: 'Thailand',
+    61: 'Slovenia', 63: 'Croatia', 64: 'Chile', 65: 'Serbia', 66: 'Malaysia', 67: 'Philippines', 68: 'Singapore',
+    69: 'Bosnia and Herzegovina', 70: 'Estonia', 71: 'Latvia', 72: 'Lithuania', 73: 'North Korea', 74: 'Uruguay',
+    75: 'Paraguay', 76: 'Bolivia', 77: 'Peru', 78: 'Colombia', 79: 'Republic of Macedonia (FYROM)', 80: 'Montenegro',
+    81: 'Republic of China (Taiwan)', 82: 'Cyprus', 83: 'Belarus', 84: 'New Zealand', 164: 'Saudi Arabia', 165: 'Egypt',
+    166: 'United Arab Emirates', 167: 'Albania', 168: 'Georgia', 169: 'Armenia', 170: 'Nigeria', 171: 'Cuba'
+}
+
+COUNTRY_LINK: Dict[int, str] = {
+    1: 'Romania', 9: 'Brazil', 11: 'France', 12: 'Germany', 13: 'Hungary', 82: 'Cyprus', 168: 'Georgia', 15: 'Spain',
+    23: 'Canada', 26: 'Mexico', 27: 'Argentina', 28: 'Venezuela', 80: 'Montenegro', 24: 'USA', 29: 'United-Kingdom',
+    50: 'Australia', 47: 'South-Korea', 171: 'Cuba', 79: 'Republic-of-Macedonia-FYROM', 30: 'Switzerland', 165: 'Egypt',
+    31: 'Netherlands', 32: 'Belgium', 33: 'Austria', 34: 'Czech-Republic', 35: 'Poland', 36: 'Slovakia', 37: 'Norway',
+    38: 'Sweden', 39: 'Finland', 40: 'Ukraine', 41: 'Russia', 42: 'Bulgaria', 43: 'Turkey', 44: 'Greece', 45: 'Japan',
+    48: 'India', 49: 'Indonesia', 78: 'Colombia', 68: 'Singapore', 51: 'South Africa', 52: 'Republic-of-Moldova',
+    53: 'Portugal', 54: 'Ireland', 55: 'Denmark', 56: 'Iran', 57: 'Pakistan', 58: 'Israel', 59: 'Thailand', 10: 'Italy',
+    61: 'Slovenia', 63: 'Croatia', 64: 'Chile', 65: 'Serbia', 66: 'Malaysia', 67: 'Philippines', 70: 'Estonia',
+    77: 'Peru', 71: 'Latvia', 72: 'Lithuania', 73: 'North-Korea', 74: 'Uruguay', 75: 'Paraguay', 76: 'Bolivia',
+    81: 'Republic-of-China-Taiwan', 166: 'United-Arab-Emirates', 167: 'Albania', 69: 'Bosnia-Herzegovina', 14: 'China',
+    169: 'Armenia', 83: 'Belarus', 84: 'New-Zealand', 164: 'Saudi-Arabia', 170: 'Nigeria'
+}
+
+ISO_CC: Dict[int, str] = {
+    1: 'ROU', 9: 'BRA', 10: 'ITA', 11: 'FRA', 12: 'DEU', 13: 'HUN', 14: 'CHN', 15: 'ESP', 23: 'CAN', 24: 'USA',
+    26: 'MEX', 27: 'ARG', 28: 'VEN', 29: 'GBR', 30: 'CHE', 31: 'NLD', 32: 'BEL', 33: 'AUT', 34: 'CZE', 35: 'POL',
+    36: 'SVK', 37: 'NOR', 38: 'SWE', 39: 'FIN', 40: 'UKR', 41: 'RUS', 42: 'BGR', 43: 'TUR', 44: 'GRC', 45: 'JPN',
+    47: 'KOR', 48: 'IND', 49: 'IDN', 50: 'AUS', 51: 'ZAF', 52: 'MDA', 53: 'PRT', 54: 'IRL', 55: 'DNK', 56: 'IRN',
+    57: 'PAK', 58: 'ISR', 59: 'THA', 61: 'SVN', 63: 'HRV', 64: 'CHL', 65: 'SRB', 66: 'MYS', 67: 'PHL', 68: 'SGP',
+    69: 'BiH', 70: 'EST', 71: 'LVA', 72: 'LTU', 73: 'PRK', 74: 'URY', 75: 'PRY', 76: 'BOL', 77: 'PER', 78: 'COL',
+    79: 'MKD', 80: 'MNE', 81: 'TWN', 82: 'CYP', 83: 'BLR', 84: 'NZL', 164: 'SAU', 165: 'EGY', 166: 'UAE', 167: 'ALB',
+    168: 'GEO', 169: 'ARM', 170: 'NGA', 171: 'CUB',
+}
+
+
+def now() -> datetime.datetime:
+    return datetime.datetime.now(erep_tz).replace(microsecond=0)
+
+
+def localize_timestamp(timestamp: int) -> datetime.datetime:
+    return datetime.datetime.fromtimestamp(timestamp, erep_tz)
+
+
+def localize_dt(dt: Union[datetime.date, datetime.datetime]) -> datetime.datetime:
+    try:
+        try:
+            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:
+    """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)
+
+
+def eday_from_date(date: Union[datetime.date, datetime.datetime] = now()) -> int:
+    if isinstance(date, datetime.date):
+        date = datetime.datetime.combine(date, datetime.time(0, 0, 0))
+    return (date - datetime.datetime(2007, 11, 20, 0, 0, 0)).days
+
+
+def date_from_eday(eday: int) -> datetime.date:
+    return localize_dt(datetime.date(2007, 11, 20)) + datetime.timedelta(days=eday)
+
+
+def get_sleep_seconds(time_until: datetime.datetime) -> int:
+    """ time_until aware datetime object Wrapper for sleeping until """
+    sleep_seconds = int((time_until - now()).total_seconds())
+    return sleep_seconds if sleep_seconds > 0 else 0
+
+
+def interactive_sleep(sleep_seconds: int):
+    while sleep_seconds > 0:
+        seconds = sleep_seconds
+        if (seconds - 1) // 1800:
+            seconds = seconds % 1800 if seconds % 1800 else 1800
+        elif (seconds - 1) // 300:
+            seconds = seconds % 300 if seconds % 300 else 300
+        elif (seconds - 1) // 60:
+            seconds = seconds % 60 if seconds % 60 else 60
+        # elif (seconds - 1) // 30:
+        #     seconds = seconds % 30 if seconds % 30 else 30
+        else:
+            seconds = 1
+        sys.stdout.write("\rSleeping for {:4} more seconds".format(sleep_seconds))
+        sys.stdout.flush()
+        time.sleep(seconds)
+        sleep_seconds -= seconds
+    sys.stdout.write("\r")
+
+
+silent_sleep = time.sleep
+
+
+def _write_log(msg, timestamp: bool = True, should_print: bool = False):
+    erep_time_now = now()
+    txt = "[{}] {}".format(erep_time_now.strftime('%F %T'), msg) if timestamp else msg
+    txt = "\n".join(["\n".join(textwrap.wrap(line, 120)) for line in txt.splitlines()])
+    if not os.path.isdir('log'):
+        os.mkdir('log')
+    with open("log/%s.log" % erep_time_now.strftime('%F'), 'a', encoding="utf-8") as f:
+        f.write("%s\n" % txt)
+    if should_print:
+        print(txt)
+
+
+def write_interactive_log(*args, **kwargs):
+    _write_log(should_print=True, *args, **kwargs)
+
+
+def write_silent_log(*args, **kwargs):
+    _write_log(should_print=False, *args, **kwargs)
+
+
+def get_file(filepath: str) -> str:
+    file = Path(filepath)
+    if file.exists():
+        if file.is_dir():
+            return str(file / "new_file.txt")
+        else:
+            version = 1
+            try:
+                version = int(file.suffix[1:]) + 1
+                basename = file.stem
+            except ValueError:
+                basename = file.name
+                version += 1
+
+            full_name = file.parent / f"{basename}.{version}"
+            while full_name.exists():
+                version += 1
+                full_name = file.parent / f"{basename}.{version}"
+            return str(full_name)
+    else:
+        os.makedirs(file.parent, exist_ok=True)
+        return str(file)
+
+
+def write_file(filename: str, content: str) -> int:
+    filename = get_file(filename)
+    with open(filename, 'ab') as f:
+        return f.write(content.encode("utf-8"))
+
+
+def write_request(response: requests.Response, is_error: bool = False):
+    from erepublik import Citizen
+    # Remove GET args from url name
+    url = response.url
+    last_index = url.index("?") if "?" in url else len(response.url)
+
+    name = slugify(response.url[len(Citizen.url):last_index])
+    html = response.text
+
+    try:
+        json.loads(html)
+        ext = "json"
+    except json.decoder.JSONDecodeError:
+        ext = "html"
+
+    if not is_error:
+        filename = "debug/requests/{}_{}.{}".format(now().strftime('%F_%H-%M-%S'), name, ext)
+        write_file(filename, html)
+    else:
+        return {"name": "{}_{}.{}".format(now().strftime('%F_%H-%M-%S'), name, ext),
+                "content": html.encode('utf-8'),
+                "mimetype": "application/json" if ext == "json" else "text/html"}
+
+
+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>"
+    if isinstance(player, Citizen):
+        resp = write_request(player.r, is_error=True)
+    else:
+        resp = {"name": "None.html", "mimetype": "text/html",
+                "content": file_content_template.format(body="<br/>".join(content), title="Error"), }
+
+    if promo:
+        resp = {"name": "%s.html" % name, "mimetype": "text/html",
+                "content": file_content_template.format(title="Promo", body="<br/>".join(content))}
+        subject = "[eBot][{}] Promos: {}".format(now().strftime('%F %T'), name)
+
+    elif captcha:
+        resp = {"name": "%s.html" % name, "mimetype": "text/html",
+                "content": file_content_template.format(title="ReCaptcha", body="<br/>".join(content))}
+        subject = "[eBot][{}] RECAPTCHA: {}".format(now().strftime('%F %T'), name)
+    else:
+        subject = "[eBot][%s] Bug trace: %s" % (now().strftime('%F %T'), name)
+
+    body = "".join(traceback.format_stack()) + \
+           "\n\n" + \
+           "\n".join(content)
+    data = dict(send_mail=True, subject=subject, bugtrace=body)
+    if promo:
+        data.update({'promo': True})
+    elif captcha:
+        data.update({'captcha': True})
+    else:
+        data.update({"bug": True})
+
+    files = [('file', (resp.get("name"), resp.get("content"), resp.get("mimetype"))), ]
+    filename = "log/%s.log" % now().strftime('%F')
+    if os.path.isfile(filename):
+        files.append(('file', (filename[4:], open(filename, 'rb'), "text/plain")))
+    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, cls=MyJSONEncoder, sort_keys=True), "application/json")))
+    if isinstance(player, Citizen):
+        files.append(('file', ("instance.json", player.to_json(indent=True), "application/json")))
+    requests.post('https://pasts.72.lv', data=data, files=files)
+
+
+def normalize_html_json(js: str) -> str:
+    js = re.sub(r' \'(.*?)\'', lambda a: '"%s"' % a.group(1), js)
+    js = re.sub(r'(\d\d):(\d\d):(\d\d)', r'\1\2\3', js)
+    js = re.sub(r'([{\s,])(\w+)(:)(?!"})', r'\1"\2"\3', js)
+    js = re.sub(r',\s*}', '}', js)
+    return js
+
+
+def caught_error(e: Exception):
+    process_error(str(e), "Unclassified", sys.exc_info(), None, COMMIT_ID, False)
+
+
+def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commit_id: str = None,
+                  interactive: Optional[bool] = None):
+    """
+    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: Caller's code version's commit id
+    :type commit_id: str
+    """
+    type_, value_, traceback_ = exc_info
+    content = [log_info]
+    content += [f"eRepublik version {VERSION}, commit id {COMMIT_ID}"]
+    if commit_id:
+        content += [f"Commit id {commit_id}"]
+    content += [str(value_), str(type_), ''.join(traceback.format_tb(traceback_))]
+
+    if interactive:
+        write_interactive_log(log_info)
+    elif interactive is not None:
+        write_silent_log(log_info)
+    trace = inspect.trace()
+    if trace:
+        trace = trace[-1][0].f_locals
+        if trace.get('__name__') == '__main__':
+            trace = {'commit_id': trace.get('COMMIT_ID'),
+                     'interactive': trace.get('INTERACTIVE'),
+                     'version': trace.get('__version__'),
+                     'config': trace.get('CONFIG')}
+    else:
+        trace = dict()
+    send_email(name, content, citizen, local_vars=trace)
+
+
+def process_warning(log_info: str, name: str, exc_info: tuple, citizen=None, commit_id: str = None):
+    """
+    Process error logging and email sending to developer
+    :param log_info: String to be written in output
+    :param name: String Instance name
+    :param exc_info: tuple output from sys.exc_info()
+    :param citizen: Citizen instance
+    :param commit_id: Code's version by commit id
+    """
+    type_, value_, traceback_ = exc_info
+    content = [log_info]
+    if commit_id:
+        content += ["Commit id: %s" % commit_id]
+    content += [str(value_), str(type_), ''.join(traceback.format_tb(traceback_))]
+
+    trace = inspect.trace()
+    if trace:
+        trace = trace[-1][0].f_locals
+    else:
+        trace = dict()
+    send_email(name, content, citizen, local_vars=trace)
+
+
+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.
+    Remove characters that aren't alphanumerics, underscores, or hyphens.
+    Convert to lowercase. Also strip leading and trailing whitespace.
+    """
+    value = str(value)
+    if allow_unicode:
+        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()
+    return re.sub(r'[-\s]+', '-', value)
+
+
+def calculate_hit(strength: float, rang: int, tp: bool, elite: bool, ne: bool, booster: int = 0,
+                  weapon: int = 200, is_deploy: bool = False) -> Decimal:
+    dec = 3 if is_deploy else 0
+    base_str = (1 + Decimal(str(round(strength, 3))) / 400)
+    base_rnk = (1 + Decimal(str(rang / 5)))
+    base_wpn = (1 + Decimal(str(weapon / 100)))
+    dmg = 10 * base_str * base_rnk * base_wpn
+
+    if elite:
+        dmg = dmg * 11 / 10
+
+    if tp and rang >= 70:
+        dmg = dmg * (1 + Decimal((rang - 69) / 10))
+
+    dmg = dmg * (100 + booster) / 100
+
+    if ne:
+        dmg = dmg * 11 / 10
+    return round(dmg, dec)
+
+
+def get_ground_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_patriot: bool = False,
+                             booster: int = 0, weapon_power: int = 200) -> Decimal:
+    r = requests.get(f"https://www.erepublik.com/en/main/citizen-profile-json/{citizen_id}").json()
+    rang = r['military']['militaryData']['ground']['rankNumber']
+    strength = r['military']['militaryData']['ground']['strength']
+    elite = r['citizenAttributes']['level'] > 100
+    if natural_enemy:
+        true_patriot = True
+
+    return calculate_hit(strength, rang, true_patriot, elite, natural_enemy, booster, weapon_power)
+
+
+def get_air_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_patriot: bool = False, booster: int = 0,
+                          weapon_power: int = 0) -> Decimal:
+    r = requests.get(f"https://www.erepublik.com/en/main/citizen-profile-json/{citizen_id}").json()
+    rang = r['military']['militaryData']['aircraft']['rankNumber']
+    elite = r['citizenAttributes']['level'] > 100
+    return calculate_hit(0, rang, true_patriot, elite, natural_enemy, booster, weapon_power)

erepublik_script/__init__.py

@@ -1,11 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""Top-level package for eRepublik script."""
-
-__author__ = """Eriks Karls"""
-__email__ = 'eriks@72.lv'
-__version__ = '0.14.4'
-
-from erepublik_script import classes, utils
-from erepublik_script.citizen import Citizen
-

erepublik_script/utils.py

@@ -1,315 +0,0 @@
-import datetime
-import inspect
-import json
-import os
-import re
-import sys
-import time
-import traceback
-from collections import deque
-from decimal import Decimal
-from json import JSONEncoder
-from pathlib import Path
-from typing import Union
-
-import pytz
-import requests
-from requests import Response
-from slugify import slugify
-
-
-__all__ = ["FOOD_ENERGY", "COMMIT_ID", "COUNTRIES", "erep_tz",
-           "now", "localize_dt", "localize_timestamp", "good_timedelta", "eday_from_date", "date_from_eday",
-           "get_sleep_seconds", "interactive_sleep", "silent_sleep",
-           "write_silent_log", "write_interactive_log", "get_file", "write_file",
-           "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"
-
-erep_tz = pytz.timezone('US/Pacific')
-AIR_RANKS = {1: "Airman", 2: "Airman 1st Class", 3: "Airman 1st Class*", 4: "Airman 1st Class**",
-             5: "Airman 1st Class***", 6: "Airman 1st Class****", 7: "Airman 1st Class*****",
-             8: "Senior Airman", 9: "Senior Airman*", 10: "Senior Airman**", 11: "Senior Airman***",
-             12: "Senior Airman****", 13: "Senior Airman*****",
-             14: "Staff Sergeant", 15: "Staff Sergeant*", 16: "Staff Sergeant**", 17: "Staff Sergeant***",
-             18: "Staff Sergeant****", 19: "Staff Sergeant*****",
-             20: "Aviator", 21: "Aviator*", 22: "Aviator**", 23: "Aviator***", 24: "Aviator****", 25: "Aviator*****",
-             26: "Flight Lieutenant", 27: "Flight Lieutenant*", 28: "Flight Lieutenant**", 29: "Flight Lieutenant***",
-             30: "Flight Lieutenant****", 31: "Flight Lieutenant*****",
-             32: "Squadron Leader", 33: "Squadron Leader*", 34: "Squadron Leader**", 35: "Squadron Leader***",
-             36: "Squadron Leader****", 37: "Squadron Leader*****",
-             38: "Chief Master Sergeant", 39: "Chief Master Sergeant*", 40: "Chief Master Sergeant**",
-             41: "Chief Master Sergeant***", 42: "Chief Master Sergeant****", 43: "Chief Master Sergeant*****",
-             44: "Wing Commander", 45: "Wing Commander*", 46: "Wing Commander**", 47: "Wing Commander***",
-             48: "Wing Commander****", 49: "Wing Commander*****",
-             50: "Group Captain", 51: "Group Captain*", 52: "Group Captain**", 53: "Group Captain***",
-             54: "Group Captain****", 55: "Group Captain*****",
-             56: "Air Commodore", 57: "Air Commodore*", 58: "Air Commodore**", 59: "Air Commodore***",
-             60: "Air Commodore****", 61: "Air Commodore*****", }
-
-GROUND_RANKS = {1: "Recruit", 2: "Private", 3: "Private*", 4: "Private**", 5: "Private***", 6: "Corporal",
-                7: "Corporal*", 8: "Corporal**", 9: "Corporal***",
-                10: "Sergeant", 11: "Sergeant*", 12: "Sergeant**", 13: "Sergeant***", 14: "Lieutenant",
-                15: "Lieutenant*", 16: "Lieutenant**", 17: "Lieutenant***",
-                18: "Captain", 19: "Captain*", 20: "Captain**", 21: "Captain***", 22: "Major", 23: "Major*",
-                24: "Major**", 25: "Major***",
-                26: "Commander", 27: "Commander*", 28: "Commander**", 29: "Commander***", 30: "Lt Colonel",
-                31: "Lt Colonel*", 32: "Lt Colonel**", 33: "Lt Colonel***",
-                34: "Colonel", 35: "Colonel*", 36: "Colonel**", 37: "Colonel***", 38: "General", 39: "General*",
-                40: "General**", 41: "General***",
-                42: "Field Marshal", 43: "Field Marshal*", 44: "Field Marshal**", 45: "Field Marshal***",
-                46: "Supreme Marshal", 47: "Supreme Marshal*", 48: "Supreme Marshal**", 49: "Supreme Marshal***",
-                50: "National Force", 51: "National Force*", 52: "National Force**", 53: "National Force***",
-                54: "World Class Force", 55: "World Class Force*", 56: "World Class Force**",
-                57: "World Class Force***", 58: "Legendary Force", 59: "Legendary Force*", 60: "Legendary Force**",
-                61: "Legendary Force***",
-                62: "God of War", 63: "God of War*", 64: "God of War**", 65: "God of War***", 66: "Titan", 67: "Titan*",
-                68: "Titan**", 69: "Titan***",
-                70: "Legends I", 71: "Legends II", 72: "Legends III", 73: "Legends IV", 74: "Legends V",
-                75: "Legends VI", 76: "Legends VII", 77: "Legends VIII", 78: "Legends IX", 79: "Legends X",
-                80: "Legends XI", 81: "Legends XII", 82: "Legends XIII", 83: "Legends XIV", 84: "Legends XV",
-                85: "Legends XVI", 86: "Legends XVII", 87: "Legends XVIII", 88: "Legends XIX", 89: "Legends XX", }
-
-COUNTRIES = {1: 'Romania', 9: 'Brazil', 10: 'Italy', 11: 'France', 12: 'Germany', 13: 'Hungary', 14: 'China',
-             15: 'Spain', 23: 'Canada', 24: 'USA', 26: 'Mexico', 27: 'Argentina', 28: 'Venezuela', 29: 'United Kingdom',
-             30: 'Switzerland', 31: 'Netherlands', 32: 'Belgium', 33: 'Austria', 34: 'Czech Republic', 35: 'Poland',
-             36: 'Slovakia', 37: 'Norway', 38: 'Sweden', 39: 'Finland', 40: 'Ukraine', 41: 'Russia', 42: 'Bulgaria',
-             43: 'Turkey', 44: 'Greece', 45: 'Japan', 47: 'South Korea', 48: 'India', 49: 'Indonesia', 50: 'Australia',
-             51: 'South Africa', 52: 'Republic of Moldova', 53: 'Portugal', 54: 'Ireland', 55: 'Denmark', 56: 'Iran',
-             57: 'Pakistan', 58: 'Israel', 59: 'Thailand', 61: 'Slovenia', 63: 'Croatia', 64: 'Chile', 65: 'Serbia',
-             66: 'Malaysia', 67: 'Philippines', 68: 'Singapore', 69: 'Bosnia and Herzegovina', 70: 'Estonia',
-             71: 'Latvia', 72: 'Lithuania', 73: 'North Korea', 74: 'Uruguay', 75: 'Paraguay', 76: 'Bolivia', 77: 'Peru',
-             78: 'Colombia', 79: 'Republic of Macedonia (FYROM)', 80: 'Montenegro', 81: 'Republic of China (Taiwan)',
-             82: 'Cyprus', 83: 'Belarus', 84: 'New Zealand', 164: 'Saudi Arabia', 165: 'Egypt',
-             166: 'United Arab Emirates', 167: 'Albania', 168: 'Georgia', 169: 'Armenia', 170: 'Nigeria', 171: 'Cuba'}
-
-
-class MyJSONEncoder(JSONEncoder):
-    def default(self, o):
-        if isinstance(o, 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)
-        elif isinstance(o, datetime.date):
-            return dict(__type__='date', year=o.year, month=o.month, day=o.day)
-        elif isinstance(o, datetime.timedelta):
-            return dict(__type__='timedelta', days=o.days, seconds=o.seconds,
-                        microseconds=o.microseconds, total_seconds=o.total_seconds())
-        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():
-    return datetime.datetime.now(erep_tz).replace(microsecond=0)
-
-
-def localize_timestamp(timestamp: int):
-    return datetime.datetime.fromtimestamp(timestamp, erep_tz)
-
-
-def localize_dt(dt: Union[datetime.date, datetime.datetime]):
-    if isinstance(dt, datetime.date):
-        dt = datetime.datetime.combine(dt, datetime.time(0, 0, 0))
-    return erep_tz.localize(dt)
-
-
-def good_timedelta(dt: datetime.datetime, td: datetime.timedelta) -> datetime.datetime:
-    return erep_tz.normalize(dt + td)
-
-
-def eday_from_date(date: Union[datetime.date, datetime.datetime] = now()) -> int:
-    if isinstance(date, datetime.date):
-        date = datetime.datetime.combine(date, datetime.time(0, 0, 0))
-    return (date - datetime.datetime(2007, 11, 20, 0, 0, 0)).days
-
-
-def date_from_eday(eday: int) -> datetime.date:
-    return localize_dt(datetime.date(2007, 11, 20)) + datetime.timedelta(days=eday)
-
-
-def get_sleep_seconds(time_untill: datetime.datetime) -> int:
-    """ time_until aware datetime object Wrapper for sleeping until """
-    sleep_seconds = int((time_untill - now()).total_seconds())
-    return sleep_seconds if sleep_seconds > 0 else 0
-
-
-def interactive_sleep(sleep_seconds: int):
-    while sleep_seconds > 0:
-        seconds = sleep_seconds
-        if (seconds - 1) // 1800:
-            seconds = seconds % 1800 if seconds % 1800 else 1800
-        elif (seconds - 1) // 300:
-            seconds = seconds % 300 if seconds % 300 else 300
-        elif (seconds - 1) // 60:
-            seconds = seconds % 60 if seconds % 60 else 60
-        # elif (seconds - 1) // 30:
-        #     seconds = seconds % 30 if seconds % 30 else 30
-        else:
-            seconds = 1
-        sys.stdout.write("\rSleeping for {:4} more seconds".format(sleep_seconds))
-        sys.stdout.flush()
-        time.sleep(seconds)
-        sleep_seconds -= seconds
-    sys.stdout.write("\r")
-
-
-silent_sleep = time.sleep
-
-
-def _write_log(msg, timestamp: bool = True, should_print: bool = False):
-    erep_time_now = now()
-    txt = "[{}] {}".format(erep_time_now.strftime('%F %T'), msg) if timestamp else msg
-    if not os.path.isdir('log'):
-        os.mkdir('log')
-    with open("log/%s.log" % erep_time_now.strftime('%F'), 'a', encoding="utf-8") as f:
-        f.write("%s\n" % txt)
-    if should_print:
-        print(txt)
-
-
-def write_interactive_log(*args, **kwargs):
-    _write_log(should_print=True, *args, **kwargs)
-
-
-def write_silent_log(*args, **kwargs):
-    _write_log(should_print=False, *args, **kwargs)
-
-
-def get_file(filepath: str) -> str:
-    file = Path(filepath)
-    if file.exists():
-        if file.is_dir():
-            return str(file / "new_file.txt")
-        else:
-            version = 1
-            try:
-                version = int(file.suffix[1:]) + 1
-                basename = file.stem
-            except ValueError:
-                basename = file.name
-                version += 1
-
-            full_name = file.parent / f"{basename}.{version}"
-            while full_name.exists():
-                version += 1
-                full_name = file.parent / f"{basename}.{version}"
-            return str(full_name)
-    else:
-        os.makedirs(file.parent, exist_ok=True)
-        return str(file)
-
-
-def write_file(filename: str, content: str) -> int:
-    filename = get_file(filename)
-    with open(filename, 'ab') as f:
-        return f.write(content.encode("utf-8"))
-
-
-def write_request(response: requests.Response, is_error: bool = False):
-    from erepublik_script import Citizen
-    # Remove GET args from url name
-    url = response.url
-    last_index = url.index("?") if "?" in url else len(response.url)
-
-    name = slugify(response.url[len(Citizen.url):last_index])
-    html = response.text
-
-    try:
-        json.loads(html)
-        ext = "json"
-    except json.decoder.JSONDecodeError:
-        ext = "html"
-
-    if not is_error:
-        filename = "debug/requests/{}_{}.{}".format(now().strftime('%F_%H-%M-%S'), name, ext)
-        write_file(filename, html)
-    else:
-        return {"name": "{}_{}.{}".format(now().strftime('%F_%H-%M-%S'), name, ext),
-                "content": html.encode('utf-8'),
-                "mimetype": "application/json" if ext == "json" else "text/html"}
-
-
-def send_email(name, content: list, player=None, local_vars=dict, promo: bool = False, captcha: bool = False):
-    from erepublik_script import Citizen
-
-    file_content_template = "<html><head><title>{title}</title></head><body>{body}</body></html>"
-    if isinstance(player, Citizen):
-        resp = write_request(player.r, is_error=True)
-    else:
-        resp = {"name": "None.html", "mimetype": "text/html",
-                "content": file_content_template.format(body="<br/>".join(content), title="Error"), }
-
-    if promo:
-        resp = {"name": "%s.html" % name, "mimetype": "text/html",
-                "content": file_content_template.format(title="Promo", body="<br/>".join(content))}
-        subject = "[eBot][{}] Promos: {}".format(now().strftime('%F %T'), name)
-
-    elif captcha:
-        resp = {"name": "%s.html" % name, "mimetype": "text/html",
-                "content": file_content_template.format(title="ReCaptcha", body="<br/>".join(content))}
-        subject = "[eBot][{}] RECAPTCHA: {}".format(now().strftime('%F %T'), name)
-    else:
-        subject = "[eBot][%s] Bug trace: %s" % (now().strftime('%F %T'), name)
-
-    body = "".join(traceback.format_stack()) + \
-           "\n\n" + \
-           "\n".join(content)
-    data = dict(send_mail=True, subject=subject, bugtrace=body)
-    if promo:
-        data.update({'promo': True})
-    elif captcha:
-        data.update({'captcha': True})
-    else:
-        data.update({"bug": True})
-
-    files = [('file', (resp.get("name"), resp.get("content"), resp.get("mimetype"))), ]
-    filename = "log/%s.log" % now().strftime('%F')
-    if os.path.isfile(filename):
-        files.append(('file', (filename[4:], open(filename, 'rb'), "text/plain")))
-    if local_vars:
-        if "state_thread" in local_vars:
-            local_vars.pop('state_thread', None)
-        files.append(('file', ("local_vars.json", json.dumps(local_vars, indent=2,
-                                                             cls=MyJSONEncoder, sort_keys=True), "application/json")))
-    if isinstance(player, Citizen):
-        files.append(('file', ("instance.json", player.to_json(indent=True), "application/json")))
-    requests.post('https://pasts.72.lv', data=data, files=files)
-
-
-def normalize_html_json(js: str) -> str:
-    js = re.sub(r' \'(.*?)\'', lambda a: '"%s"' % a.group(1), js)
-    js = re.sub(r'(\d\d):(\d\d):(\d\d)', r'\1\2\3', js)
-    js = re.sub(r'([{\s,])(\w+)(:)(?!"})', r'\1"\2"\3', js)
-    js = re.sub(r',\s*}', '}', js)
-    return js
-
-
-def process_error(log_info: str, name: str, exc_info: tuple, citizen=None, commit_id: str = None,
-                  interactive: bool = False):
-    """
-    Process error logging and email sending to developer
-    :param error:
-    :param interactive: Should print interactively
-    :param log_info: String to be written in output
-    :param name: String Instance name
-    :param exc_info: tuple output from sys.exc_info()
-    :param citizen: Citizen instance
-    :param commit_id: Code's version by commit id
-    """
-    type_, value_, traceback_ = exc_info
-    bugtrace = [] if not commit_id else ["Commit id: %s" % commit_id, ]
-    bugtrace += [str(value_), str(type_), ''.join(traceback.format_tb(traceback_))]
-
-    if interactive:
-        write_interactive_log(log_info)
-    else:
-        write_silent_log(log_info)
-    send_email(name, bugtrace, citizen, local_vars=inspect.trace()[-1][0].f_locals)

examples/battle_launcher.py

@@ -0,0 +1,98 @@
+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,
+    'battle_launcher': {
+        # War id: {auto_attack: bool (attack asap when region is available), regions: [region_ids allowed to attack]}
+        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[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(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 Exception as e:
+            player.report_error(f"Task battle launcher ran into error {e}")
+
+
+# noinspection DuplicatedCode
+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('battle_launcher'):
+        name = "{}-battle_launcher-{}".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,106 @@
+from datetime import timedelta
+
+from erepublik import Citizen, utils
+
+CONFIG = {
+    'email': 'player@email.com',
+    'password': 'Pa$5w0rd!',
+    'interactive': True,
+    'debug': True
+}
+
+
+# noinspection DuplicatedCode
+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:
+        try:
+            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_as_manager()
+                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)
+        except Exception as e:
+            player.report_error(f"Task main loop ran into error: {e}")
+
+
+if __name__ == "__main__":
+    main()

requirements_dev.txt

@@ -1,15 +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.1.2
-twine==1.13.0
-ipython==7.6.1
-PyInstaller==3.5
-pytz==2019.1
-requests==2.22.0
-pycryptodome==3.8.2
-python-slugify==2.0.1
+bump2version==1.0.0
+coverage==5.1
+edx-sphinx-theme==1.5.0
+flake8==3.8.3
+ipython==7.15.0
+isort==4.3.21
+pip==20.1.1
+PyInstaller==3.6
+pytz==2020.1
+requests==2.23.0
+setuptools==47.1.1
+Sphinx==3.1.1
+tox==3.15.2
+twine==3.1.1
+watchdog==0.10.2
+wheel==0.34.2

set_commit_id.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+commit=$(git log -1 --pretty=format:%h)
+sed -i.bak -E "s|__commit_id__ = \".+\"|__commit_id__ = \"${commit}\"|g" erepublik/__init__.py
+rm erepublik/__init__.py.bak

setup.cfg

@@ -1,13 +1,17 @@
 [bumpversion]
-current_version = 0.14.4
+current_version = 0.20.1
 commit = True
 tag = True
+parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)\.?(?P<dev>\d+)?
+serialize = 
+	{major}.{minor}.{patch}.{dev}
+	{major}.{minor}.{patch}
 
 [bumpversion:file:setup.py]
 search = version='{current_version}'
 replace = version='{new_version}'
 
-[bumpversion:file:erepublik_script/__init__.py]
+[bumpversion:file:erepublik/__init__.py]
 search = __version__ = '{current_version}'
 replace = __version__ = '{new_version}'
 
@@ -17,7 +21,6 @@ universal = 1
 [flake8]
 exclude = docs
 max-line-length = 120
-ignore = E722
+ignore = E722 F401
 
 [aliases]
-

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', 'python-slugify<3.0.0']
+requirements = ['pytz==2020.1', 'requests==2.23.0']
 
 setup_requirements = []
 
@@ -21,26 +21,28 @@ setup(
     author="Eriks Karls",
     author_email='eriks@72.lv',
     classifiers=[
-        'Development Status :: 2 - Pre-Alpha',
+        'Development Status :: 4 - Beta',
         'Intended Audience :: Developers',
         'License :: OSI Approved :: MIT License',
         'Natural Language :: English',
         'Programming Language :: Python :: 3',
         'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
     ],
-    description="Python package for eRepublik automated playing",
+    description="Python package for automated eRepublik playing",
     entry_points={},
     install_requires=requirements,
     license="MIT license",
     long_description=readme + '\n\n' + history,
     include_package_data=True,
-    keywords='erepublik_script',
-    name='erepublik_script',
-    packages=find_packages(include=['erepublik_script']),
+    keywords='erepublik',
+    name='eRepublik',
+    packages=find_packages(include=['erepublik']),
+    python_requires='>=3.7, <4',
     setup_requires=setup_requirements,
     test_suite='tests',
     tests_require=test_requirements,
-    url='https://github.com/eeriks/erepublik_script',
-    version='0.14.4',
+    url='https://github.com/eeriks/erepublik/',
+    version='0.20.1',
     zip_safe=False,
 )

tests/__init__.py

@@ -1,3 +1,3 @@
 # -*- coding: utf-8 -*-
 
-"""Unit test package for erepublik_script."""
+"""Unit test package for erepublik."""

tests/test_erepublik_script.py

@@ -1,34 +1,134 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-"""Tests for `erepublik_script` package."""
-
+"""Tests for `erepublik` package."""
 
 import unittest
-from click.testing import CliRunner
 
-from erepublik_script import Citizen
-from erepublik_script import cli
+from erepublik import Citizen
 
 
-class TestErepublik_script(unittest.TestCase):
-    """Tests for `erepublik_script` package."""
+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):
-        """Tear down test fixtures, if any."""
+    def test_should_do_levelup(self):
+        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):
-        """Test something."""
+        self.citizen.energy.recoverable = 1000
+        self.assertFalse(self.citizen.should_do_levelup)
 
-    def test_command_line_interface(self):
-        """Test the CLI."""
-        runner = CliRunner()
-        result = runner.invoke(cli.main)
-        assert result.exit_code == 0
-        assert 'erepublik_script.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
+    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, "Fighting not allowed!", False))
+
+        self.citizen.config.fight = True
+
+        # Level up
+        self.citizen.energy.limit = 3000
+        self.citizen.details.xp = 24705
+        self.assertEqual(self.citizen.should_fight(), (0, 'Level up', False))
+
+        self.citizen.energy.recovered = 3000
+        self.citizen.energy.recoverable = 2950
+        self.citizen.energy.interval = 30
+        self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), (900, 'Level up', True))
+        self.citizen.my_companies.ff_lockdown = 0
+
+        # Level up reachable
+        self.citizen.details.xp = 24400
+        self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), (305, 'Fighting for close Levelup. Doing 305 hits', True))
+        self.citizen.my_companies.ff_lockdown = 0
+
+        self.citizen.details.xp = 21000
+        self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), (75, 'Obligatory fighting for at least 75pp', True))
+        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, 'Fighting all-in. Doing 595 hits', False))
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), (
+            435, 'Fight count modified (old count: 595 | FF: 595 | WAM ff_lockdown: 160 | New count: 435)', False
+        ))
+        self.citizen.my_companies.ff_lockdown = 0
+
+        self.citizen.config.air = True
+        self.citizen.energy.recoverable = 1000
+        self.assertEqual(self.citizen.should_fight(), (400, 'Fighting all-in in AIR. Doing 400 hits', False))
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), (
+            240, 'Fight count modified (old count: 400 | FF: 400 | WAM ff_lockdown: 160 | New count: 240)', False
+        ))
+        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, 'Fighting for +1 energy. Doing 320 hits', False))
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), (
+            160, 'Fight count modified (old count: 320 | FF: 400 | WAM ff_lockdown: 160 | New count: 160)', False
+        ))
+        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, 'Fighting for 1h energy. Doing 30 hits', True))

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