.editorconfig

@@ -21,7 +21,7 @@ insert_final_newline = false
 indent_style = tab
 
 [*.py]
-max_line_length = 120
+max_line_length = 240
 line_length=120
 multi_line_output=0
 balanced_wrapping=True

.flake8

@@ -1,5 +0,0 @@
-[flake8]
-ignore = E203,E722
-exclude = .git,__pycache__,venv,docs,debug,log
-max-line-length = 120
-#max-complexity = 10

.github/workflows/codeql-analysis.yml

@@ -1,71 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ master ]
-  schedule:
-    - cron: '16 0 * * 0'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'python' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
-        # Learn more:
-        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        # queries: ./path/to/local/query, your-org/your-repo/queries@main
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
-
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
-
-    #- run: |
-    #   make bootstrap
-    #   make release
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1

.github/workflows/pythonpackage.yml

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.8, 3.9]
+        python-version: [3.7, 3.8]
 
     steps:
     - uses: actions/checkout@v2
@@ -19,15 +19,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install -r requirements-dev.txt
-    - name: Lint with isort
-      run: |
-        pip install -U isort
-        isort --check erepublik
-    - name: Lint with Black
-      run: |
-        pip install -U black
-        black --check erepublik
+        pip install -r requirements_dev.txt
     - name: Lint with flake8
       run: |
         pip install flake8
@@ -35,7 +27,7 @@ jobs:
         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
+    - name: Test with pytest
+      run: |
+        pip install pytest
+        pytest

.gitignore

@@ -103,4 +103,3 @@ ENV/
 debug/
 log/
 *dump.json
-.idea/

.pre-commit-config.yaml

@@ -0,0 +1,13 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.2.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: check-added-large-files
+
+default_language_version:
+    python: python3.8

.readthedocs.yaml

@@ -1,15 +0,0 @@
-version: 2
-
-build:
-  os: "ubuntu-20.04"
-  tools:
-    python: "3.9"
-
-# Build from the docs/ directory with Sphinx
-sphinx:
-  configuration: docs/conf.py
-
-# Explicitly set the version of Python and its requirements
-python:
-  install:
-    - requirements: requirements-dev.txt

CONTRIBUTING.rst

@@ -58,10 +58,10 @@ Ready to contribute? Here's how to set up `erepublik` for local development.
 
     $ git clone git@github.com:your_name_here/erepublik.git
 
-3. This is how you set up your fork for local development::
+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
     $ cd erepublik/
-    $ python3 -m venv venv
     $ python setup.py develop
 
 4. Create a branch for local development::
@@ -73,7 +73,8 @@ Ready to contribute? Here's how to set up `erepublik` for local development.
 5. When you're done making changes, check that your changes pass flake8, isort and the
    tests::
 
-    $ make lint
+    $ flake8 erepublik tests
+    $ isort erepublik
     $ python setup.py test
 
    To get flake8 and isort, just pip install them into your virtualenv.
@@ -114,6 +115,8 @@ A reminder for the maintainers on how to deploy.
 Make sure all your changes are committed (including an entry in HISTORY.rst).
 Then run::
 
-$ bumpversion patch # possible: major / minor / patch / dev
+$ bumpversion patch # possible: major / minor / patch
 $ git push
 $ git push --tags
+
+Travis will then deploy to PyPI if tests pass.

LICENSE

@@ -1,674 +1,21 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.
+MIT License
+
+Copyright (c) 2019, Eriks Karls
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -52,14 +52,12 @@ clean-test: ## remove test and coverage artifacts
 	rm -fr .pytest_cache
 
 lint: ## check style with flake8
-	isort erepublik examples tests
-	black erepublik examples tests
-	flake8 erepublik examples tests
+	flake8 erepublik tests
 
 test: ## run tests quickly with the default Python
-	python -m unittest
+	python setup.py test
 
-coverage: lint ## check code coverage quickly with the default Python
+coverage: ## check code coverage quickly with the default Python
 	coverage run --source erepublik setup.py test
 	coverage report -m
 	coverage html

README.rst

@@ -10,13 +10,16 @@ eRepublik script
         :target: https://erepublik.readthedocs.io/en/latest/?badge=latest
         :alt: Documentation Status
 
+.. image:: https://api.codacy.com/project/badge/Grade/eaa7ae43d23f4c0abab65c3bde89475a
+        :target: https://app.codacy.com/manual/eeriks/erepublik?utm_source=github.com&utm_medium=referral&utm_content=eeriks/erepublik&utm_campaign=Badge_Grade_Dashboard
+        :alt: Codacy Badge
+
 
 Python package for automated eRepublik playing
 
 
-* Free software: GPLv3.0
+* Free software: MIT license
 * Documentation: https://erepublik.readthedocs.io/en/latest/
-* Source code: https://github.com/eeriks/erepublik
 
 
 Features

docs/conf.py

@@ -20,14 +20,10 @@
 #
 import os
 import sys
-
-sys.path.insert(0, os.path.abspath(".."))
-
-import datetime
-
-import edx_theme
+sys.path.insert(0, os.path.abspath('..'))
 
 import erepublik
+import edx_theme
 
 # -- General configuration ---------------------------------------------
 
@@ -37,24 +33,24 @@ import erepublik
 
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ["sphinx.ext.autodoc", "sphinx.ext.viewcode", "edx_theme"]
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode', 'edx_theme']
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ["_templates"]
+templates_path = ['_templates']
 
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
 #
 # source_suffix = ['.rst', '.md']
-source_suffix = ".rst"
+source_suffix = '.rst'
 
 # The master toctree document.
-master_doc = "index"
+master_doc = 'index'
 
 # General information about the project.
-project = "eRepublik script"
-copyright = "2017-%i, Eriks Karls" % datetime.date.today().year
-author = "Eriks Karls"
+project = u'eRepublik script'
+copyright = u"2019, Eriks Karls"
+author = u"Eriks Karls"
 
 # The version info for the project you're documenting, acts as replacement
 # for |version| and |release|, also used in various other places throughout
@@ -75,10 +71,10 @@ language = None
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = "sphinx"
+pygments_style = 'sphinx'
 
 # If true, `todo` and `todoList` produce output, else they produce nothing.
 todo_include_todos = False
@@ -89,7 +85,7 @@ 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 = "edx_theme"
+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
@@ -101,13 +97,13 @@ html_theme_path = [edx_theme.get_html_theme_path()]
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-# html_static_path = ["_static"]
+html_static_path = ['_static']
 
 
 # -- Options for HTMLHelp output ---------------------------------------
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = "erepublikdoc"
+htmlhelp_basename = 'erepublikdoc'
 
 
 # -- Options for LaTeX output ------------------------------------------
@@ -116,12 +112,15 @@ latex_elements = {
     # The paper size ('letterpaper' or 'a4paper').
     #
     # 'papersize': 'letterpaper',
+
     # The font size ('10pt', '11pt' or '12pt').
     #
     # 'pointsize': '10pt',
+
     # Additional stuff for the LaTeX preamble.
     #
     # 'preamble': '',
+
     # Latex figure (float) alignment
     #
     # 'figure_align': 'htbp',
@@ -131,7 +130,9 @@ latex_elements = {
 # (source start file, target name, title, author, documentclass
 # [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, "erepublik.tex", "eRepublik script Documentation", "Eriks Karls", "manual"),
+    (master_doc, 'erepublik.tex',
+     u'eRepublik script Documentation',
+     u'Eriks Karls', 'manual'),
 ]
 
 
@@ -139,7 +140,11 @@ latex_documents = [
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [(master_doc, "erepublik", "eRepublik script Documentation", [author], 1)]
+man_pages = [
+    (master_doc, 'erepublik',
+     u'eRepublik script Documentation',
+     [author], 1)
+]
 
 
 # -- Options for Texinfo output ----------------------------------------
@@ -148,13 +153,10 @@ man_pages = [(master_doc, "erepublik", "eRepublik script Documentation", [author
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (
-        master_doc,
-        "erepublik",
-        "eRepublik script Documentation",
+    (master_doc, 'erepublik',
+     u'eRepublik script Documentation',
      author,
-        "erepublik",
-        "One line description of project.",
-        "Miscellaneous",
-    ),
+     'erepublik',
+     'One line description of project.',
+     'Miscellaneous'),
 ]

docs/erepublik.rst

@@ -44,6 +44,14 @@ erepublik.utils module
    :undoc-members:
    :show-inheritance:
 
+erepublik.ws module
+-------------------
+
+.. automodule:: erepublik.ws
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
 Module contents
 ---------------
 

docs/index.html

@@ -8,10 +8,12 @@
     <meta name="generator" content="Jekyll v4.0.1">
     <title>eBot configuration</title>
     <!-- CSS only -->
-    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.6.0/dist/css/bootstrap.min.css" integrity="sha384-B0vP5xmATw1+K9KRQjQERJvTumQW0nPEzvF6L/Z6nronJ3oUOFUFpCjEUQouq2+l" crossorigin="anonymous">
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.5.3/dist/css/bootstrap.min.css" integrity="sha384-TX8t27EcRE3e/ihU7zmQxVncDAy5uIKz4rEkgIXeMed4M0jlfIDPvg6uqKI2xXr2" crossorigin="anonymous">
+
     <!-- JS, Popper.js, and jQuery -->
     <script src="https://code.jquery.com/jquery-3.5.1.slim.min.js" integrity="sha384-DfXdz2htPH0lsSSs5nCTpuj/zy4C+OGpamoFVy38MVBnE+IbbVYUew+OrCXaRkfj" crossorigin="anonymous"></script>
-    <script src="https://cdn.jsdelivr.net/npm/bootstrap@4.6.0/dist/js/bootstrap.bundle.min.js" integrity="sha384-Piv4xVNRyMGpqkS2by6br4gNJ7DXjqk09RmUpJ8jgGtD7zP9yug3goQfGII0yAns" crossorigin="anonymous"></script>
+    <script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.1/dist/umd/popper.min.js" integrity="sha384-9/reFTGAW83EW2RDu2S0VKaIzap3H66lZH81PoYlFhbGU+6BZp6G7niu735Sk7lN" crossorigin="anonymous"></script>
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@4.5.3/dist/js/bootstrap.min.js" integrity="sha384-w1Q4orYjBQndcko6MimVbzY0tgp4pWB4lZ7lr30WKz0vr/aWKhXdBNmNb5D92v7s" crossorigin="anonymous"></script>
 </head>
 <body>
 <div class="container">
@@ -118,57 +120,57 @@
                     </div>
 
                     <div class="col-12 col-sm-6">
-                        <h3><span style="text-decoration: line-through;">Fighting</span></h3>
+                        <h3>Fighting</h3>
                         <div class="form-group">
                             <div class="custom-control custom-switch">
-                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="fight" disabled>
+                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="fight" checked>
                                 <label class="custom-control-label" for="fight">Fight</label>
                             </div>
                             <div class="custom-control custom-switch custom-control-inline">
-                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="air" disabled>
+                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="air" checked>
                                 <label class="custom-control-label" for="air">Air</label>
                             </div>
                             <div class="custom-control custom-switch custom-control-inline">
-                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="ground" disabled>
+                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="ground">
                                 <label class="custom-control-label" for="ground">Ground</label>
                             </div>
                             <div class="custom-control custom-switch">
-                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="boosters" disabled>
+                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="boosters">
                                 <label class="custom-control-label" for="boosters">Use ground boosters</label>
                             </div>
                             <div class="custom-control custom-switch">
-                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="continuous_fighting" disabled>
+                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="continuous_fighting">
                                 <label class="custom-control-label" for="continuous_fighting">Continue fighting all FF in round</label>
                             </div>
                             <div class="custom-control custom-switch">
-                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="next_energy" disabled>
+                                <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="next_energy" checked>
                                 <label class="custom-control-label" for="next_energy">Fight for next WC +1hp/6min if reachable by FF</label>
                             </div>
                         </div>
                         <div class="form-group">
                             <div class="form-check form-check-inline">
-                                <input type="radio" class="form-check-input" onchange="updateJson()" id="all_in" name="fight_amount" value="all_in" disabled>
+                                <input type="radio" class="form-check-input" onchange="updateJson()" id="all_in" name="fight_amount" value="all_in">
                                 <label class="form-check-label" for="all_in">All energy</label>
                             </div>
                             <div class="form-check form-check-inline">
-                                <input type="radio" class="form-check-input" onchange="updateJson()" id="h_energy" name="fight_amount" value="h_energy"  disabled>
+                                <input type="radio" class="form-check-input" onchange="updateJson()" id="h_energy" name="fight_amount" value="h_energy" checked>
                                 <label class="form-check-label" for="h_energy">1h energy</label>
                             </div>
                         </div>
                         <div class="custom-control custom-switch">
-                            <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="rw_def_side" disabled>
+                            <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="rw_def_side" checked>
                             <label class="custom-control-label" for="rw_def_side">In RWs fight on right side (occupier/defender)</label>
                         </div>
                         <div class="custom-control custom-switch">
-                            <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="travel_to_fight" disabled>
+                            <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="travel_to_fight" checked>
                             <label class="custom-control-label" for="travel_to_fight">Travel to fight</label>
                         </div>
                         <div class="custom-control custom-switch">
-                            <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="epic_hunt" disabled>
+                            <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="epic_hunt">
                             <label class="custom-control-label" for="epic_hunt">Hunt epics</label>
                         </div>
                         <div class="custom-control custom-switch">
-                            <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="epic_hunt_ebs" disabled>
+                            <input type="checkbox" class="custom-control-input" onchange="updateJson()" id="epic_hunt_ebs">
                             <label class="custom-control-label" for="epic_hunt_ebs">Spend <small>[all]</small> EBs in epics</label>
                         </div>
                     </div>
@@ -260,13 +262,7 @@
             </form>
         </div>
         <div class="col-12">
-            <div class="card">
-                <div class="card-body">
-                    <h5 class="card-title">config.json</h5>
-                    <h6 class="card-subtitle mb-2 text-muted">Copy-paste the content below into 'config.json' file</h6>
-                    <pre id="json-output" class="bg-light card-text"></pre>
-                </div>
-            </div>
+            <pre id="json-output"></pre>
         </div>
     </div>
 </div>

erepublik/Fighting

@@ -1,859 +0,0 @@
-
-
-
-# TODO: Fix fighting and reimplement CitizenMilitary module
-# class CitizenMilitary(CitizenTravel):
-#     all_battles: Dict[int, classes.Battle] = None
-#     __last_war_update_data = None
-#
-#     active_fs: bool = False
-#
-#     @property
-#     def as_dict(self):
-#         d = super().as_dict
-#         d.update(active_fs=self.active_fs, all_battles=self.all_battles)
-#         return d
-#     def update_all():
-#         super().update_all()
-#         self.update_war_info()
-#
-#     def update_war_info(self):
-#         if (
-#             self.__last_war_update_data
-#             and self.__last_war_update_data.get("last_updated", 0) + 30 > self.now.timestamp()
-#         ):
-#             r_json = self.__last_war_update_data
-#         else:
-#             r_json = self._get_military_campaigns_json_list().json()
-#         if r_json.get("countries"):
-#             if self.all_battles is None:
-#                 self.all_battles = {}
-#             self.__last_war_update_data = r_json
-#             if r_json.get("battles"):
-#                 all_battles = {}
-#                 for battle_data in r_json.get("battles", {}).values():
-#                     all_battles[battle_data.get("id")] = classes.Battle(battle_data)
-#                 # old_all_battles = self.all_battles
-#                 self.all_battles = all_battles
-#                 # for battle in old_all_battles.values():
-#                 #     utils._clear_up_battle_memory(battle)
-#
-#     def get_battle_for_war(self, war_id: int) -> Optional[classes.Battle]:
-#         self.update_war_info()
-#         war_info = self.get_war_status(war_id)
-#         return self.all_battles.get(war_info.get("battle_id"), None)
-#
-#     def get_war_status(self, war_id: int) -> Dict[str, Union[bool, Dict[int, str]]]:
-#         r = self._get_wars_show(war_id)
-#         html = r.text
-#         ret = {}
-#         reg_re = re.compile(fr'data-war-id="{war_id}" data-region-id="(\d+)" data-region-name="([- \w]+)"')
-#         if reg_re.findall(html):
-#             ret.update(regions={}, can_attack=True)
-#             for reg in reg_re.findall(html):
-#                 ret["regions"].update({int(reg[0]): reg[1]})
-#         elif re.search(
-#             r'<a href="//www.erepublik.com/en/military/battlefield/(\d+)" '
-#             r'class="join" title="Join"><span>Join</span></a>',
-#             html,
-#         ):
-#             battle_id = re.search(
-#                 r'<a href="//www.erepublik.com/en/military/battlefield/(\d+)" '
-#                 r'class="join" title="Join"><span>Join</span></a>',
-#                 html,
-#             ).group(1)
-#             ret.update(can_attack=False, battle_id=int(battle_id))
-#         elif re.search(r"This war is no longer active.", html):
-#             ret.update(can_attack=False, ended=True)
-#         else:
-#             ret.update(can_attack=False)
-#         return ret
-#
-#     def get_available_weapons(self, battle_id: int):
-#         return self._get_military_show_weapons(battle_id).json()
-#
-#     def set_default_weapon(self, battle: classes.Battle, division: classes.BattleDivision) -> int:
-#         available_weapons = self._get_military_show_weapons(battle.id).json()
-#         while not isinstance(available_weapons, list):
-#             available_weapons = self._get_military_show_weapons(battle.id).json()
-#         weapon_quality = -1
-#         weapon_damage = 0
-#         if not division.is_air:
-#             for weapon in available_weapons:
-#                 try:
-#                     if weapon["weaponQuantity"] > 30 and weapon["weaponInfluence"] > weapon_damage:
-#                         weapon_quality = int(weapon["weaponId"])
-#                         weapon_damage = weapon["weaponInfluence"]
-#                 except ValueError:
-#                     pass
-#         return self.change_weapon(battle, weapon_quality, division)
-#
-#     def change_weapon(self, battle: classes.Battle, quality: int, battle_zone: classes.BattleDivision) -> int:
-#         r = self._post_military_change_weapon(battle.id, battle_zone.id, quality)
-#         influence = r.json().get("weaponInfluence")
-#         self._report_action(
-#             "MILITARY_WEAPON", f"Switched to q{quality} weapon," f" new influence {influence}", kwargs=r.json()
-#         )
-#         return influence
-#
-#     def sorted_battles(self, sort_by_time: bool = True, only_tp=False) -> List[classes.Battle]:
-#         cs_battles_priority_air: List[classes.Battle] = []
-#         cs_battles_priority_ground: List[classes.Battle] = []
-#         cs_battles_air: List[classes.Battle] = []
-#         cs_battles_ground: List[classes.Battle] = []
-#         deployed_battles_air: List[classes.Battle] = []
-#         deployed_battles_ground: List[classes.Battle] = []
-#         ally_battles_air: List[classes.Battle] = []
-#         ally_battles_ground: List[classes.Battle] = []
-#         other_battles_air: List[classes.Battle] = []
-#         other_battles_ground: List[classes.Battle] = []
-#
-#         ret_battles: List[classes.Battle] = []
-#         if sort_by_time:
-#             battle_list = sorted(self.all_battles.values(), key=lambda b: b.start)
-#             battle_list.reverse()
-#         else:
-#             battle_list = sorted(self.all_battles.values(), key=lambda b: b.id)
-#
-#         contribution_json = self._get_military_campaigns_json_citizen().json()
-#         contributions: List[Dict[str, int]] = contribution_json.get("contributions") or []
-#         contributions.sort(key=lambda b: -b.get("damage"))
-#
-#         for contribution_battle in contributions:
-#             if contribution_battle.get("battle_id") and contribution_battle.get("battle_id") in self.all_battles:
-#                 ret_battles.append(self.all_battles[contribution_battle.get("battle_id")])
-#
-#         for battle in battle_list:
-#             battle_sides = [battle.invader.country, battle.defender.country]
-#             if battle.id in ret_battles:
-#                 continue
-#             # CS Battles
-#             elif self.details.citizenship in battle_sides:
-#                 if battle.has_air:
-#                     if battle.defender.id == self.details.citizenship:
-#                         cs_battles_priority_air.append(battle)
-#                     else:
-#                         cs_battles_air.append(battle)
-#                 else:
-#                     if battle.defender.id == self.details.citizenship:
-#                         cs_battles_priority_ground.append(battle)
-#                     else:
-#                         cs_battles_ground.append(battle)
-#
-#             # Current location battles:
-#             elif self.details.current_country in battle_sides:
-#                 if battle.has_air:
-#                     deployed_battles_air.append(battle)
-#                 else:
-#                     deployed_battles_ground.append(battle)
-#
-#             # Deployed battles and allied battles:
-#             elif self.details.current_country in battle.invader.allies + battle.defender.allies + battle_sides:
-#                 if self.details.current_country in battle.invader.deployed + battle.defender.deployed:
-#                     if battle.has_air:
-#                         deployed_battles_air.append(battle)
-#                     else:
-#                         deployed_battles_ground.append(battle)
-#                 # Allied battles:
-#                 else:
-#                     if battle.has_air:
-#                         ally_battles_air.append(battle)
-#                     else:
-#                         ally_battles_ground.append(battle)
-#             else:
-#                 if battle.has_air:
-#                     other_battles_air.append(battle)
-#                 else:
-#                     other_battles_ground.append(battle)
-#
-#         cs_battles = cs_battles_priority_air + cs_battles_priority_ground + cs_battles_air + cs_battles_ground
-#         if only_tp:
-#             return cs_battles
-#         deployed_battles = deployed_battles_air + deployed_battles_ground
-#         other_battles = ally_battles_air + ally_battles_ground + other_battles_air + other_battles_ground
-#         ret_battles = ret_battles + cs_battles + deployed_battles + other_battles
-#         return ret_battles
-#
-#     def get_cheap_tp_divisions(self) -> Dict[str, List[Tuple[int, classes.BattleDivision]]]:
-#         air_divs: List[Tuple[int, classes.BattleDivision]] = []
-#         ground_divs: List[Tuple[int, classes.BattleDivision]] = []
-#         check_maverick = self.maverick and self.config.maverick
-#         for battle in reversed(self.sorted_battles(True, True)):
-#             for division in battle.div.values():
-#                 is_start_ok = utils.good_timedelta(division.battle.start, timedelta(minutes=-1)) < self.now
-#                 if not division.terrain and is_start_ok and not division.div_end:
-#                     if division.is_air and self.config.air:
-#                         division_medals = self.get_battle_round_data(division)
-#                         medal = division_medals[self.details.citizenship == division.battle.defender.country]
-#                         if not medal:
-#                             air_divs.append((0, division))
-#                         else:
-#                             air_divs.append((medal.get("1").get("raw_value"), division))
-#                     elif not division.is_air and self.config.ground:
-#                         if not division.div == self.division and not check_maverick:
-#                             continue
-#                         division_medals = self.get_battle_round_data(division)
-#                         medal = division_medals[self.details.citizenship == division.battle.defender.country]
-#                         if not medal:
-#                             ground_divs.append((0, division))
-#                         else:
-#                             ground_divs.append((medal.get("1").get("raw_value"), division))
-#
-#         air_divs.sort(key=lambda z: (z[0], z[1].battle.start))
-#         ground_divs.sort(key=lambda z: (z[0], z[1].battle.start))
-#         return {"air": air_divs, "ground": ground_divs}
-#
-#     @property
-#     def has_battle_contribution(self):
-#         return bool(self.__last_war_update_data.get("citizen_contribution", []))
-#
-#     def find_battle_to_fight(
-#         self, silent: bool = False
-#     ) -> Tuple[classes.Battle, classes.BattleDivision, classes.BattleSide]:
-#         self.update_war_info()
-#         for battle in self.sorted_battles(self.config.sort_battles_time):
-#             if not isinstance(battle, classes.Battle):
-#                 continue
-#             if battle.is_dict_lib:
-#                 continue
-#             battle_zone: Optional[classes.BattleDivision] = None
-#             for div in battle.div.values():
-#                 if div.terrain == 0:
-#                     if div.div_end:
-#                         continue
-#                     maverick_ok = self.maverick and self.config.maverick
-#                     if self.config.air and div.is_air:
-#                         battle_zone = div
-#                         break
-#                     elif self.config.ground and not div.is_air and (div.div == self.division or maverick_ok):
-#                         battle_zone = div
-#                         break
-#                     else:
-#                         continue
-#             if not battle_zone:
-#                 continue
-#             allies = (
-#                 battle.invader.deployed + battle.defender.deployed + [battle.invader.country, battle.defender.country]
-#             )
-#
-#             travel_needed = self.details.current_country not in allies
-#
-#             if battle.is_rw:
-#                 side = battle.defender if self.config.rw_def_side else battle.invader
-#             else:
-#                 defender_side = self.details.current_country in battle.defender.allies + [
-#                     battle.defender.country,
-#                 ]
-#                 side = battle.defender if defender_side else battle.invader
-#
-#             if not silent:
-#                 self.write_log(str(battle))
-#
-#             travel = (
-#                 (self.config.travel_to_fight and self.should_travel_to_fight() or self.config.force_travel)
-#                 if travel_needed
-#                 else True
-#             )
-#
-#             if not travel:
-#                 continue
-#             yield battle, battle_zone, side
-#
-#     def find_battle_and_fight(self):
-#         count = self.should_fight()[0]
-#         if count:
-#             self.write_log("Checking for battles to fight in...")
-#             for battle, division, side in self.find_battle_to_fight():
-#
-#                 allies = (
-#                     battle.invader.deployed
-#                     + battle.defender.deployed
-#                     + [battle.invader.country, battle.defender.country]
-#                 )
-#
-#                 travel_needed = self.details.current_country not in allies
-#
-#                 if battle.start > self.now:
-#                     self.sleep(utils.get_sleep_seconds(battle.start))
-#
-#                 if travel_needed and not self.change_division(battle, division, side):
-#                     break
-#
-#                 if self.change_division(battle, division):
-#                     self.set_default_weapon(battle, division)
-#                     self.fight(battle, division, side, count)
-#                     self.travel_to_residence()
-#                     break
-#
-#     def fight(
-#         self,
-#         battle: classes.Battle,
-#         division: classes.BattleDivision,
-#         side: classes.BattleSide = None,
-#         count: int = None,
-#     ) -> Optional[int]:
-#         """Fight in a battle.
-#
-#         Will auto activate booster and travel if allowed to do it.
-#         :param battle: Battle battle to fight in
-#         :type battle: Battle
-#         :param division: Division number to fight in available choices
-#         :type division: BattleDivision
-#         :param side: BattleSide or None. Battle side to fight in, If side not == invader id or not in invader deployed
-#         allies list, then defender's side is chosen
-#         :type side: BattleSide
-#         :param count: How many hits to do, if not specified self.should_fight() is called.
-#         :type count: int
-#         :param use_ebs: Should use energy bars if count > 0 and not enough food_fights
-#         :type use_ebs: bool
-#         :return: None if no errors while fighting, otherwise error count.
-#         :rtype: int
-#         """
-#         if self.restricted_ip:
-#             self.write_warning("Fighting is not allowed from restricted IP!")
-#             self._report_action("IP_BLACKLISTED", "Fighting is not allowed from restricted IP!")
-#             return 1
-#         if not division.is_air and self.config.boosters:
-#             self.activate_damage_booster(not division.is_air)
-#         if side is None:
-#             side = (
-#                 battle.defender
-#                 if self.details.citizenship in battle.defender.allies + [battle.defender.country]
-#                 else battle.invader
-#             )
-#         if count is None:
-#             count = self.should_fight()[0]
-#
-#         self.write_log(f"Fighting in battle for {battle.region_name} on {side} side in d{division.div}")
-#
-#         if self.now < utils.localize_dt(datetime(2021, 2, 8)):
-#             error_count = total_damage = total_hits = 0
-#             ok_to_fight = True
-#             while ok_to_fight and error_count < 10 and count > 0:
-#                 while all((count > 0, error_count < 10, self.energy.energy >= 50)):
-#                     hits, error, damage = self._shoot(battle, division, side)
-#                     count -= hits
-#                     total_hits += hits
-#                     total_damage += damage
-#                     error_count += error
-#                 else:
-#                     if self.energy.energy < 50 or error_count >= 10 or count <= 0:
-#                         self.write_log(f"Hits: {total_hits:>4} | Damage: {total_damage}")
-#                         ok_to_fight = False
-#                         if total_damage:
-#                             self.report_fighting(battle, not side.is_defender, division, total_damage, total_hits)
-#             return error_count
-#         else:
-#             deployment_id = self.deploy(division, side, count * 10)
-#             self.sleep(count // 3)  # TODO: connect to eRepublik's WS and get from there when deploy ends
-#             energy_used = 0
-#             if deployment_id:
-#                 self.write_warning(
-#                     "If eRepublik responds with HTTP 500 Internal Error, "
-#                     "it is kind of ok, because deployment has not finished yet."
-#                 )
-#                 deployment_data = self._post_military_fight_deploy_deploy_report_data(deployment_id).json()
-#                 if not deployment_data.get("error"):
-#                     data = deployment_data["data"]
-#                     total_damage = int(data["damage"].replace(",", ""))
-#                     energy_used = int(data["energySpent"].replace(",", ""))
-#                     self.details.pp += int(data["rewards"]["prestigePoints"].replace(",", ""))
-#                     self.report_fighting(battle, not side.is_defender, division, total_damage, energy_used // 10)
-#             return energy_used
-#
-#     def _shoot(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide):
-#         if division.is_air:
-#             response = self._post_military_fight_air(battle.id, side.id, division.id)
-#         else:
-#             response = self._post_military_fight_ground(battle.id, side.id, division.id)
-#
-#         if "Zone is not meant for " in response.text:
-#             self.sleep(5)
-#             return 0, 1, 0
-#         try:
-#             r_json = response.json()
-#         except (ValueError, HTTPError, RequestException):
-#             return 0, 10, 0
-#         hits = 0
-#         damage = 0
-#         err = False
-#         if r_json.get("error"):
-#             if r_json.get("message") == "SHOOT_LOCKOUT":
-#                 pass
-#             elif r_json.get("message") == "NOT_ENOUGH_WEAPONS":
-#                 self.set_default_weapon(battle, division)
-#             elif r_json.get("message") == "Cannot activate a zone with a non-native division":
-#                 self.write_warning("Wrong division!!")
-#                 return 0, 10, 0
-#             elif r_json.get("message") == "ZONE_INACTIVE":
-#                 self.write_warning("Wrong division!!")
-#                 return 0, 10, 0
-#             elif r_json.get("message") == "NON_BELLIGERENT":
-#                 self.write_warning("Dictatorship/Liberation wars are not supported!")
-#                 return 0, 10, 0
-#             elif r_json.get("message") in ["FIGHT_DISABLED", "DEPLOYMENT_MODE"]:
-#                 self._post_main_profile_update(
-#                     "options", params='{"optionName":"enable_web_deploy","optionValue":"off"}'
-#                 )
-#                 self.set_default_weapon(battle, division)
-#             else:
-#                 if r_json.get("message") == "UNKNOWN_SIDE":
-#                     self._rw_choose_side(battle, side)
-#                 elif r_json.get("message") == "CHANGE_LOCATION":
-#                     countries = [side.country] + side.deployed
-#                     self.travel_to_battle(battle, countries)
-#                 err = True
-#         elif r_json.get("message") == "ENEMY_KILLED":
-#             # Non-InfantryKit players
-#             if r_json["user"]["earnedXp"]:
-#                 hits = r_json["user"]["earnedXp"]
-#             # InfantryKit player
-#             # The almost always safe way (breaks on levelup hit)
-#             elif self.energy.energy >= r_json["details"]["wellness"]:  # Haven't reached levelup
-#                 hits = (self.energy.energy - r_json["details"]["wellness"]) // 10
-#             else:
-#                 hits = r_json["hits"]
-#                 if r_json["user"]["epicBattle"]:
-#                     hits /= 1 + r_json["user"]["epicBattle"]
-#
-#             self.energy.energy = r_json["details"]["wellness"]
-#             self.details.xp = int(r_json["details"]["points"])
-#             damage = r_json["user"]["givenDamage"] * (1.1 if r_json["oldEnemy"]["isNatural"] else 1)
-#         else:
-#             err = True
-#
-#         return hits, err, damage
-#
-#     def deploy_bomb(
-#         self, battle: classes.Battle, division: classes.BattleDivision, bomb_id: int, inv_side: bool, count: int = 1
-#     ) -> Optional[int]:
-#         """Deploy bombs in a battle for given side.
-#
-#         :param battle: Battle
-#         :type battle: classes.Battle
-#         :param division: BattleDivision
-#         :type division: classes.BattleDivision
-#         :param bomb_id: int bomb id
-#         :type bomb_id: int
-#         :param inv_side: should deploy on invader side
-#         :type inv_side: bool
-#         :param count: how many bombs to deploy
-#         :type count: int
-#         :return: Deployed count
-#         :rtype: int
-#         """
-#
-#         if not isinstance(count, int) or count < 1:
-#             count = 1
-#         has_traveled = False
-#         if battle.is_rw:
-#             has_traveled = self.travel_to_battle(battle, [battle.defender.country])
-#             self._rw_choose_side(battle, battle.invader if inv_side else battle.defender)
-#         if inv_side:
-#             good_countries = [battle.invader.country] + battle.invader.deployed
-#             if self.details.current_country not in good_countries:
-#                 has_traveled = self.travel_to_battle(battle, good_countries)
-#         else:
-#             involved = (
-#                 [battle.invader.country, battle.defender.country] + battle.invader.deployed + battle.defender.deployed
-#             )
-#             if self.details.current_country not in involved:
-#                 count = 0
-#         side = battle.invader if inv_side else battle.defender
-#         errors = deployed_count = 0
-#         while (not deployed_count == count) and errors < 10:
-#             r = self._post_military_deploy_bomb(battle.id, division.id, side.id, bomb_id).json()
-#             if not r.get("error"):
-#                 deployed_count += 1
-#                 self.sleep(0.5)
-#             elif r.get("message") == "LOCKED":
-#                 self.sleep(0.5)
-#             elif r.get("message") == "INVALID_BOMB":
-#                 errors = 10
-#             else:
-#                 errors += 1
-#
-#         if has_traveled:
-#             self.travel_to_residence()
-#
-#         self._report_action("MILITARY_BOMB", f"Deployed {deployed_count} bombs in battle {battle.id}")
-#         return deployed_count
-#
-#     def change_division(
-#         self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide = None
-#     ) -> bool:
-#         """Change division.
-#
-#         :param battle: classes.Battle
-#         :type battle: classes.Battle
-#         :param division: int target division to switch to
-#         :type division: classes.BattleDivision
-#         :param side: Side to choose
-#         :type side: classes.BattleSide
-#         :return:
-#         """
-#         resp = self._post_main_battlefield_change_division(battle.id, division.id, side.id if side else None)
-#         if resp.json().get("error"):
-#             self.write_warning(resp.json().get("message"))
-#             return False
-#         self._report_action(
-#             "MILITARY_DIV_SWITCH", f"Switched to d{division.div} in battle {battle.id}", kwargs=resp.json()
-#         )
-#         return True
-#
-#     def get_ground_hit_dmg_value(
-#         self,
-#         rang: int = None,
-#         strength: float = None,
-#         elite: bool = None,
-#         ne: bool = False,
-#         booster_50: bool = False,
-#         booster_100: bool = False,
-#         tp: bool = True,
-#     ) -> Decimal:
-#         if not rang or not strength or elite is None:
-#             r = self._get_main_citizen_profile_json(self.details.citizen_id).json()
-#             if not rang:
-#                 rang = r["military"]["militaryData"]["ground"]["rankNumber"]
-#             if not strength:
-#                 strength = r["military"]["militaryData"]["ground"]["strength"]
-#             if elite is None:
-#                 elite = r["citizenAttributes"]["level"] > 100
-#         if ne:
-#             tp = True
-#
-#         return utils.calculate_hit(strength, rang, tp, elite, ne, 50 if booster_50 else 100 if booster_100 else 0)
-#
-#     def get_air_hit_dmg_value(
-#         self, rang: int = None, elite: bool = None, ne: bool = False, weapon: bool = False
-#     ) -> Decimal:
-#         if not rang or elite is None:
-#             r = self._get_main_citizen_profile_json(self.details.citizen_id).json()
-#             if not rang:
-#                 rang = r["military"]["militaryData"]["aircraft"]["rankNumber"]
-#             if elite is None:
-#                 elite = r["citizenAttributes"]["level"] > 100
-#
-#         return utils.calculate_hit(0, rang, True, elite, ne, 0, 20 if weapon else 0)
-#
-#     def activate_damage_booster(self, ground: bool = True) -> int:
-#         kind = "damage" if ground else "aircraftDamage"
-#         if self.config.boosters and not self.get_active_damage_booster(ground):
-#             booster: Optional[types.InvFinalItem] = None
-#             for quality, data in sorted(self.inventory.boosters.get(kind, {}).items(), key=lambda x: x[0]):
-#                 for _duration, _booster in sorted(data.items(), key=lambda y: y[0]):
-#                     critical_amount = 2 if quality < 10 and ground else 10
-#                     if _booster.get("amount") > critical_amount:
-#                         booster = _booster
-#                         break
-#                 break
-#             if booster:
-#                 kind = "damage" if ground else "air_damage"
-#                 self._report_action("MILITARY_BOOSTER", f"Activated {booster['name']}")
-#                 resp = self._post_economy_activate_booster(booster["quality"], booster["durability"], kind).json()
-#                 self._update_inventory_data(resp)
-#         return self.get_active_damage_booster(ground)
-#
-#     def get_active_damage_booster(self, ground: bool = True) -> int:
-#         kind = "damage" if ground else "aircraftDamage"
-#         boosters = self.inventory.active.get(kind, {})
-#         quality = 0
-#         for q, boost in boosters.items():
-#             if boost["quality"] * 10 > quality:
-#                 quality = boost["quality"] * 10
-#         return quality
-#
-#     def get_active_ground_damage_booster(self) -> int:
-#         return self.get_active_damage_booster(True)
-#
-#     def get_active_air_damage_booster(self) -> int:
-#         return self.get_active_damage_booster(False)
-#
-#     def activate_battle_effect(self, battle_id: int, kind: str) -> bool:
-#         self._report_action("MILITARY_BOOSTER", f"Activated {kind} booster")
-#         resp = self._post_main_activate_battle_effect(battle_id, kind, self.details.citizen_id).json()
-#         return not resp.get("error")
-#
-#     def activate_pp_booster(self, pp_item: types.InvFinalItem) -> bool:
-#         self._report_action("MILITARY_BOOSTER", f'Activated {pp_item["name"]}')
-#         resp = self._post_economy_activate_booster(
-#             pp_item["quality"], pp_item["durability"], "prestige_points"
-#         ).json()
-#         self._update_inventory_data(resp)
-#         return pp_item.get("kind") in self.inventory.active
-#
-#     def _rw_choose_side(self, battle: classes.Battle, side: classes.BattleSide) -> Response:
-#         return self._post_main_battlefield_travel(side.id, battle.id)
-#
-#     def should_travel_to_fight(self) -> bool:
-#         ret = False
-#         if self.config.always_travel:
-#             ret = True
-#         elif self.should_do_levelup:  # Do levelup
-#             ret = True
-#         # Get to next Energy +1
-#         elif self.next_reachable_energy and self.config.next_energy:
-#             ret = True
-#         # 1h worth of energy
-#         elif self.energy.energy + self.energy.interval * 3 >= self.energy.limit:
-#             ret = True
-#         return ret
-#
-#     def should_fight(self) -> Tuple[int, str, bool]:
-#         """Checks if citizen should fight at this moment
-#         :rtype: Tuple[int, str, bool]
-#         """
-#         count = 0
-#         force_fight = False
-#         msg = "Fighting not allowed!"
-#         if not self.config.fight:
-#             return count, msg, force_fight
-#
-#         # Do levelup
-#         if self.is_levelup_reachable:
-#             msg = "Level up"
-#             if self.should_do_levelup:
-#                 count = (self.energy.limit * 3) // 10
-#                 force_fight = True
-#             else:
-#                 self.write_log("Waiting for fully recovered energy before leveling up.")
-#
-#         # Levelup reachable
-#         elif self.is_levelup_close:
-#             count = self.details.xp_till_level_up - (self.energy.limit // 10) + 5
-#             msg = "Fighting for close Levelup. Doing %i hits" % count
-#             force_fight = True
-#
-#         elif self.details.pp < 75:
-#             count = 75 - self.details.pp
-#             msg = "Obligatory fighting for at least 75pp"
-#             force_fight = True
-#
-#         elif self.config.continuous_fighting and self.has_battle_contribution:
-#             count = self.energy.food_fights
-#             msg = "Continuing to fight in previous battle"
-#
-#         # All-in (type = all-in and full ff)
-#         elif self.config.all_in and self.energy.energy + self.energy.interval * 3 >= self.energy.limit:
-#             count = self.energy.food_fights
-#             msg = "Fighting all-in. Doing %i hits" % count
-#
-#         # Get to next Energy +1
-#         elif self.config.next_energy and self.next_reachable_energy:
-#             count = self.next_reachable_energy
-#             msg = "Fighting for +1 energy. Doing %i hits" % count
-#
-#         # 1h worth of energy
-#         elif self.energy.energy + self.energy.interval * 3 >= self.energy.limit:
-#             count = self.energy.interval
-#             msg = "Fighting for 1h energy. Doing %i hits" % count
-#             force_fight = True
-#
-#         return (count if count > 0 else 0), msg, force_fight
-#
-#     def get_battle_round_data(self, division: classes.BattleDivision) -> Tuple[Any, Any]:
-#         battle = division.battle
-#
-#         r = self._post_military_battle_console(
-#             battle.id,
-#             "battleStatistics",
-#             1,
-#             zoneId=battle.zone_id,
-#             round_id=battle.zone_id,
-#             division=division.div,
-#             battleZoneId=division.id,
-#             type="damage",
-#         )
-#         r_json = r.json()
-#         return r_json.get(str(battle.invader.id)).get("fighterData"), r_json.get(str(battle.defender.id)).get(
-#             "fighterData"
-#         )
-#
-#     def get_battle_division_stats(self, division: classes.BattleDivision) -> Dict[str, Any]:
-#         battle = division.battle
-#         r = self._get_military_battle_stats(battle.id, division.div, division.id)
-#         return r.json()
-#
-#     def get_division_max_hit(self, division: classes.BattleDivision) -> int:
-#         """Returns max hit in division for current side (if not on either side returns 0)
-#
-#         :param division: BattleDivision for which to get max hit value
-#         :type division: classes.BattleDivision
-#         :return: max hit value
-#         :rtype: int
-#         """
-#         return self.get_battle_division_stats(division).get("maxHit", -1)
-#
-#     def schedule_attack(self, war_id: int, region_id: int, region_name: str, at_time: datetime):
-#         if at_time:
-#             self.sleep(utils.get_sleep_seconds(at_time))
-#         self.get_csrf_token()
-#         self.launch_attack(war_id, region_id, region_name)
-#
-#     def get_active_wars(self, country: constants.Country = None) -> List[int]:
-#         r = self._get_country_military(country.link if country else self.details.citizenship.link)
-#         all_war_ids = re.findall(r'//www\.erepublik\.com/en/wars/show/(\d+)"', r.text)
-#         return [int(wid) for wid in all_war_ids]
-#
-#     def get_last_battle_of_war_end_time(self, war_id: int) -> datetime:
-#         r = self._get_wars_show(war_id)
-#         html = r.text
-#         last_battle_id = int(re.search(
-#             r'<a href="//www.erepublik.com/en/military/battlefield/(\d+)">', html
-#         ).group(1))
-#         console = self._post_military_battle_console(last_battle_id, "warList", 1).json()
-#         battle = console.get("list")[0]
-#         return utils.localize_dt(datetime.strptime(battle.get("result").get("end"), "%Y-%m-%d %H:%M:%S"))
-#
-#     def launch_attack(self, war_id: int, region_id: int, region_name: str):
-#         self._post_wars_attack_region(war_id, region_id, region_name)
-#         self._report_action("MILITARY_QUEUE_ATTACK", f"Battle for *{region_name}* queued")
-#
-#     def get_country_mus(self, country: constants.Country) -> Dict[int, str]:
-#         ret = {}
-#         r = self._get_main_leaderboards_damage_rankings(country.id)
-#         for data in r.json()["mu_filter"]:
-#             if data["id"]:
-#                 ret.update({data["id"]: data["name"]})
-#         r = self._get_main_leaderboards_damage_aircraft_rankings(country.id)
-#         for data in r.json()["mu_filter"]:
-#             if data["id"]:
-#                 ret.update({data["id"]: data["name"]})
-#         return ret
-#
-#     def get_mu_members(self, mu_id: int) -> Dict[int, str]:
-#         ret = {}
-#         r = self._get_military_unit_data(mu_id)
-#
-#         for page in range(int(r.json()["panelContents"]["pages"])):
-#             r = self._get_military_unit_data(mu_id, currentPage=page + 1)
-#             for user in r.json()["panelContents"]["members"]:
-#                 if not user["isDead"]:
-#                     ret.update({user["citizenId"]: user["name"]})
-#         return ret
-#
-#     def get_citizen_weekly_daily_orders_done(self, citizen_id: int = None, weeks_ago: int = 0) -> int:
-#         if citizen_id is None:
-#             citizen_id = self.details.citizen_id
-#         profile = self._get_main_citizen_profile_json(citizen_id).json()
-#         mu_id = profile.get("military", {}).get("militaryUnit", {}).get("id", 0)
-#         if mu_id:
-#             name = profile.get("citizen", {}).get("name")
-#             member = self._get_military_unit_data(
-#                 mu_id,
-#                 currentPage=1,
-#                 panel="members",
-#                 sortBy="dailyOrdersCompleted",
-#                 weekFilter=f"week{weeks_ago}",
-#                 search=name,
-#             ).json()
-#             return member.get("panelContents", {}).get("members", [{}])[0].get("dailyOrdersCompleted")
-#         return 0
-#
-#     def get_possibly_empty_medals(self):
-#         self.update_war_info()
-#         for battle in self.all_battles.values():
-#             for division in battle.div.values():
-#                 if division.wall["dom"] == 50 or division.wall["dom"] > 98:
-#                     yield division, division.wall["for"] == battle.invader.country.id
-#
-#     def report_fighting(
-#         self, battle: classes.Battle, invader: bool, division: classes.BattleDivision, damage: float, hits: int
-#     ):
-#         self.reporter.report_fighting(battle, invader, division, damage, hits)
-#         if self.config.telegram:
-#             self.telegram.report_fight(battle, invader, division, damage, hits)
-#
-#     def get_deploy_inventory(self, division: classes.BattleDivision, side: classes.BattleSide):
-#         ret = self._post_fight_deploy_get_inventory(division.battle.id, side.id, division.id).json()
-#         # if ret.get('recoverableEnergyBuyFood'):
-#         #     self.buy_food()
-#         #     return self.get_deploy_inventory(division, side)
-#         if ret.get("captcha"):
-#             self.do_captcha_challenge()
-#         if ret.get("error"):
-#             if ret.get("message") == "Deployment disabled.":
-#                 self._post_main_profile_update(
-#                     "options", params='{"optionName":"enable_web_deploy","optionValue":"on"}'
-#                 )
-#                 return self.get_deploy_inventory(division, side)
-#             else:
-#                 self.report_error(f"Unable to get deployment inventory because: {ret.get('message')}")
-#         return ret
-#
-#     def deploy(self, division: classes.BattleDivision, side: classes.BattleSide, energy: int, _retry=0) -> int:
-#         _energy = int(energy)
-#         deploy_inv = self.get_deploy_inventory(division, side)
-#         if not deploy_inv["minEnergy"] <= energy <= deploy_inv["maxEnergy"]:
-#             return 0
-#         energy_sources = {}
-#         source_idx = 0
-#         recoverable = deploy_inv["recoverableEnergy"]
-#         for source in reversed(sorted(deploy_inv["energySources"], key=lambda s: (s["type"], s.get("quality", 0)))):
-#             if source["type"] == "pool":
-#                 _energy -= source["energy"]
-#             elif source["type"] in ["food", "energy_bar"]:
-#                 recovers = source["energy"] // source["amount"]
-#                 amount = (recoverable if source["type"] == "food" else _energy) // recovers
-#                 amount = amount if amount < source["amount"] else source["amount"]
-#                 if amount > 0:
-#                     energy_sources.update({f"energySources[{source_idx}][quality]": source["quality"]})
-#                     energy_sources.update({f"energySources[{source_idx}][amount]": amount})
-#                     source_idx += 1
-#                     used_energy = amount * recovers
-#                     recoverable -= used_energy
-#                     _energy -= used_energy
-#             if _energy <= 0:
-#                 break
-#         if _energy > 0:
-#             energy -= _energy
-#         weapon_q = -1
-#         weapon_strength = 0
-#         if not division.is_air:
-#             for weapon in sorted(deploy_inv["weapons"], key=lambda w: w["damageperHit"]):
-#                 if (weapon["damageperHit"] or 0) > weapon_strength and (weapon["amount"] or 0) > 50:
-#                     weapon_q = weapon["quality"]
-#         r = self._post_fight_deploy_start_deploy(
-#             division.battle.id, side.id, division.id, energy, weapon_q, **energy_sources
-#         ).json()
-#         if r.get("error"):
-#             self.report_error(f"Deploy failed: '{r.get('message')}'")
-#             if r.get("message") == "Deployment disabled.":
-#                 self._post_main_profile_update(
-#                     "options", params='{"optionName":"enable_web_deploy","optionValue":"on"}'
-#                 )
-#                 if _retry < 5:
-#                     return self.deploy(division, side, energy, _retry + 1)
-#                 else:
-#                     self.report_error("Unable to deploy 5 times!")
-#             return 0
-#         return r.get("deploymentId")
-
-    # def should_fight(self, silent: bool = True) -> Tuple[int, str, bool]:
-    #     if not hasattr(super, "should_fight"):
-    #         return 0, "Unable to fight", False
-    #     count, log_msg, force_fight = super().should_fight()
-    #
-    #     if count > 0 and not force_fight:
-    #         if self.energy.food_fights - self.my_companies.ff_lockdown < count:
-    #             log_msg = (
-    #                 f"Fight count modified (old count: {count} | FF: {self.energy.food_fights} | "
-    #                 f"WAM ff_lockdown: {self.my_companies.ff_lockdown} |"
-    #                 f" New count: {count - self.my_companies.ff_lockdown})"
-    #             )
-    #             count -= self.my_companies.ff_lockdown
-    #             if count <= 0:
-    #                 count = 0
-    #                 log_msg = f"Not fighting because WAM needs {self.my_companies.ff_lockdown} food fights"
-    #
-    #     if self.max_time_till_full_ff > self.time_till_week_change:
-    #         max_count = (int(self.time_till_week_change.total_seconds()) // 360 * self.energy.interval) // 10
-    #         log_msg = (
-    #             f"End for Weekly challenge is near (Recoverable until WC end {max_count}hp | want to do {count}hits)"
-    #         )
-    #         count = count if max_count > count else max_count
-    #
-    #     if not silent:
-    #         self.write_log(log_msg)
-    #
-    #     return count, log_msg, force_fight

erepublik/__init__.py

@@ -3,9 +3,9 @@
 """Top-level package for eRepublik script."""
 
 __author__ = """Eriks Karls"""
-__email__ = "eriks@72.lv"
-__version__ = "0.29.2.3"
+__email__ = 'eriks@72.lv'
+__version__ = '0.25.0.4'
 
 from erepublik.citizen import Citizen
 
-__all__ = ["Citizen", "__version__"]
+__all__ = ['Citizen', '__version__']

erepublik/_logging.py

@@ -19,13 +19,13 @@ from erepublik.utils import json, json_dumps, json_loads, slugify
 class ErepublikFileHandler(handlers.TimedRotatingFileHandler):
     _file_path: Path
 
-    def __init__(self, filename: str = "log/erepublik.log", *args, **kwargs):
+    def __init__(self, filename: str = 'log/erepublik.log', *args, **kwargs):
         log_path = Path(filename)
         self._file_path = log_path
         log_path.parent.mkdir(parents=True, exist_ok=True)
         at_time = erep_tz.localize(datetime.datetime.now()).replace(hour=0, minute=0, second=0, microsecond=0)
         kwargs.update(atTime=at_time)
-        super().__init__(filename, when="d", *args, **kwargs)
+        super().__init__(filename, when='d', *args, **kwargs)
 
     def doRollover(self) -> None:
         self._file_path.parent.mkdir(parents=True, exist_ok=True)
@@ -88,7 +88,7 @@ class ErepublikFormatter(logging.Formatter):
         if datefmt:
             s = dt.strftime(datefmt)
         else:
-            s = dt.strftime("%Y-%m-%d %H:%M:%S")
+            s = dt.strftime('%Y-%m-%d %H:%M:%S')
         return s
 
     def usesTime(self):
@@ -99,9 +99,9 @@ class ErepublikErrorHTTTPHandler(handlers.HTTPHandler):
     def __init__(self, reporter: Reporter):
         logging.Handler.__init__(self, level=logging.ERROR)
         self._reporter = weakref.ref(reporter)
-        self.host = "erep.lv"
-        self.url = "/ebot/error/"
-        self.method = "POST"
+        self.host = 'erep.lv'
+        self.url = '/ebot/error/'
+        self.method = 'POST'
         self.secure = True
         self.credentials = (str(reporter.citizen_id), reporter.key)
         self.context = None
@@ -115,41 +115,31 @@ class ErepublikErrorHTTTPHandler(handlers.HTTPHandler):
         url = response.url
         last_index = url.index("?") if "?" in url else len(response.url)
 
-        name = slugify(response.url[len(self.reporter.citizen.url) : last_index])
+        name = slugify(response.url[len(self.reporter.citizen.url):last_index])
         html = response.text
 
         try:
             json_loads(html)
-            ext = "json"
+            ext = 'json'
         except json.decoder.JSONDecodeError:
-            ext = "html"
+            ext = 'html'
         try:
-            resp_time = (
-                datetime.datetime.strptime(response.headers.get("date"), "%a, %d %b %Y %H:%M:%S %Z")
-                .replace(tzinfo=datetime.timezone.utc)
-                .astimezone(erep_tz)
-                .strftime("%F_%H-%M-%S")
-            )
-        except:  # noqa
-            resp_time = slugify(response.headers.get("date"))
-        return dict(
-            name=f"{resp_time}_{name}.{ext}",
-            content=html.encode("utf-8"),
-            mimetype="application/json" if ext == "json" else "text/html",
-        )
+            resp_time = datetime.datetime.strptime(
+                response.headers.get('date'), '%a, %d %b %Y %H:%M:%S %Z'
+            ).replace(tzinfo=datetime.timezone.utc).astimezone(erep_tz).strftime('%F_%H-%M-%S')
+        except:
+            resp_time = slugify(response.headers.get('date'))
+        return dict(name=f"{resp_time}_{name}.{ext}", content=html.encode('utf-8'),
+                    mimetype="application/json" if ext == 'json' else "text/html")
 
     def _get_local_vars(self) -> str:
         trace = inspect.trace()
         local_vars = {}
         if trace:
             local_vars = trace[-1][0].f_locals
-            if local_vars.get("__name__") == "__main__":
-                local_vars.update(
-                    commit_id=local_vars.get("COMMIT_ID"),
-                    interactive=local_vars.get("INTERACTIVE"),
-                    version=local_vars.get("__version__"),
-                    config=local_vars.get("CONFIG"),
-                )
+            if local_vars.get('__name__') == '__main__':
+                local_vars.update(commit_id=local_vars.get('COMMIT_ID'), interactive=local_vars.get('INTERACTIVE'),
+                                  version=local_vars.get('__version__'), config=local_vars.get('CONFIG'))
         else:
             stack = inspect.stack()
             report_error_caller_found = False
@@ -157,19 +147,18 @@ class ErepublikErrorHTTTPHandler(handlers.HTTPHandler):
                 if report_error_caller_found:
                     local_vars = frame.frame.f_locals
                     break
-                if "report_error" in str(frame.frame):
+                if 'report_error' in str(frame.frame):
                     report_error_caller_found = True
 
-        if "state_thread" in local_vars:
-            local_vars.pop("state_thread", None)
+        if 'state_thread' in local_vars:
+            local_vars.pop('state_thread', None)
         from erepublik import Citizen
-
-        if isinstance(local_vars.get("self"), Citizen):
-            local_vars["self"] = repr(local_vars["self"])
-        if isinstance(local_vars.get("player"), Citizen):
-            local_vars["player"] = repr(local_vars["player"])
-        if isinstance(local_vars.get("citizen"), Citizen):
-            local_vars["citizen"] = repr(local_vars["citizen"])
+        if isinstance(local_vars.get('self'), Citizen):
+            local_vars['self'] = repr(local_vars['self'])
+        if isinstance(local_vars.get('player'), Citizen):
+            local_vars['player'] = repr(local_vars['player'])
+        if isinstance(local_vars.get('citizen'), Citizen):
+            local_vars['citizen'] = repr(local_vars['citizen'])
         return json_dumps(local_vars)
 
     def _get_instance_json(self) -> str:
@@ -182,17 +171,15 @@ class ErepublikErrorHTTTPHandler(handlers.HTTPHandler):
 
         # Log last response
         resp = self._get_last_response()
-        files = [
-            ("file", (resp.get("name"), resp.get("content"), resp.get("mimetype"))),
-        ]
+        files = [('file', (resp.get('name'), resp.get('content'), resp.get('mimetype'))), ]
 
-        files += list(("file", (f, open(f"log/{f}", "rb"))) for f in os.listdir("log") if f.endswith(".log"))
+        files += list(('file', (f, open(f'log/{f}', 'rb'))) for f in os.listdir('log') if f.endswith('.log'))
         local_vars_json = self._get_local_vars()
         if local_vars_json:
-            files.append(("file", ("local_vars.json", local_vars_json, "application/json")))
+            files.append(('file', ('local_vars.json', local_vars_json, "application/json")))
         instance_json = self._get_instance_json()
         if instance_json:
-            files.append(("file", ("instance.json", instance_json, "application/json")))
+            files.append(('file', ('instance.json', instance_json, "application/json")))
         data.update(files=files)
         return data
 
@@ -203,12 +190,12 @@ class ErepublikErrorHTTTPHandler(handlers.HTTPHandler):
         Send the record to the Web server as a percent-encoded dictionary
         """
         try:
-            proto = "https" if self.secure else "http"
+            proto = 'https' if self.secure else 'http'
             u, p = self.credentials
-            s = "Basic " + base64.b64encode(f"{u}:{p}".encode("utf-8")).strip().decode("ascii")
-            headers = {"Authorization": s}
+            s = 'Basic ' + base64.b64encode(f'{u}:{p}'.encode('utf-8')).strip().decode('ascii')
+            headers = {'Authorization': s}
             data = self.mapLogRecord(record)
-            files = data.pop("files") if "files" in data else None
+            files = data.pop('files') if 'files' in data else None
             requests.post(f"{proto}://{self.host}{self.url}", headers=headers, data=data, files=files)
         except Exception:
             self.handleError(record)

erepublik/access_points.py

@@ -5,17 +5,37 @@ import time
 from typing import Any, Dict, List, Mapping, Union
 
 from requests import Response, Session
-from requests.exceptions import ConnectionError
 from requests_toolbelt.utils import dump
 
 from erepublik import constants, utils
 
-__all__ = ["SlowRequests", "CitizenAPI"]
+__all__ = ['SlowRequests', 'CitizenAPI']
 
 
 class SlowRequests(Session):
     last_time: datetime.datetime
     timeout: datetime.timedelta = datetime.timedelta(milliseconds=500)
+    _uas: List[str] = [
+        # Chrome
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) 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/87.0.4280.141 Safari/537.36',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36',
+
+        # FireFox
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:84.0) Gecko/20100101 Firefox/84.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:82.0) Gecko/20100101 Firefox/82.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:81.0) Gecko/20100101 Firefox/81.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:84.0) Gecko/20100101 Firefox/84.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:83.0) Gecko/20100101 Firefox/83.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:82.0) Gecko/20100101 Firefox/82.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:81.0) Gecko/20100101 Firefox/81.0',
+    ]
     debug: bool = False
 
     def __init__(self, proxies: Dict[str, str] = None, user_agent: str = None):
@@ -23,32 +43,21 @@ class SlowRequests(Session):
         if proxies:
             self.proxies = proxies
         if user_agent is None:
-            user_agent = self.get_random_user_agent()
+            user_agent = random.choice(self._uas)
         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": user_agent})
+        self.headers.update({'User-Agent': user_agent})
         self.hooks["response"] = [self._log_response]
 
     @property
     def as_dict(self):
-        return dict(
-            last_time=self.last_time,
-            timeout=self.timeout,
-            cookies=self.cookies.get_dict(),
-            debug=self.debug,
-            user_agent=self.headers["User-Agent"],
-            request_log_name=self.request_log_name,
-            proxies=self.proxies,
-        )
+        return dict(last_time=self.last_time, timeout=self.timeout, cookies=self.cookies.get_dict(), debug=self.debug,
+                    user_agent=self.headers['User-Agent'], request_log_name=self.request_log_name, proxies=self.proxies)
 
     def request(self, method, url, *args, **kwargs):
         self._slow_down_requests()
         self._log_request(url, method, **kwargs)
-        try:
         resp = super().request(method, url, *args, **kwargs)
-        except ConnectionError:
-            time.sleep(1)
-            return self.request(method, url, *args, **kwargs)
         # self._log_response(resp)
         return resp
 
@@ -62,72 +71,49 @@ class SlowRequests(Session):
     def _log_request(self, url, method, data=None, json=None, params=None, **kwargs):
         if self.debug:
             args = {}
-            kwargs.pop("allow_redirects", None)
+            kwargs.pop('allow_redirects', None)
             if kwargs:
-                args.update({"kwargs": kwargs})
+                args.update({'kwargs': kwargs})
 
             if data:
-                args.update({"data": data})
+                args.update({'data': data})
 
             if json:
-                args.update({"json": json})
+                args.update({'json': json})
 
             if params:
-                args.update({"params": params})
+                args.update({'params': params})
 
             body = f"[{utils.now().strftime('%F %T')}]\tURL: '{url}'\tMETHOD: {method}\tARGS: {args}\n"
-            with open(self.request_log_name, "ab") as file:
+            with open(self.request_log_name, 'ab') as file:
                 file.write(body.encode("UTF-8"))
 
     def _log_response(self, response: Response, *args, **kwargs):
-        redirect = kwargs.get("redirect")
+        redirect = kwargs.get('redirect')
         url = response.request.url
         if self.debug:
             if response.history and not redirect:
                 for hist_resp in response.history:
-                    self._log_request(hist_resp.request.url, "REDIRECT")
+                    self._log_request(hist_resp.request.url, 'REDIRECT')
                     self._log_response(hist_resp, redirect=True)
 
-            fd_path = "debug/requests"
-            fd_time = self.last_time.strftime("%Y/%m/%d/%H-%M-%S")
-            fd_name = utils.slugify(url[len(CitizenBaseAPI.url) :])
-            fd_extra = "_REDIRECT" if redirect else ""
+            fd_path = 'debug/requests'
+            fd_time = self.last_time.strftime('%Y/%m/%d/%H-%M-%S')
+            fd_name = utils.slugify(url[len(CitizenBaseAPI.url):])
+            fd_extra = '_REDIRECT' if redirect else ""
 
             try:
                 utils.json.loads(response.text)
-                fd_ext = "json"
+                fd_ext = 'json'
             except utils.json.JSONDecodeError:
-                fd_ext = "html"
+                fd_ext = 'html'
 
-            filename = f"{fd_path}/{fd_time}_{fd_name}{fd_extra}.{fd_ext}"
+            filename = f'{fd_path}/{fd_time}_{fd_name}{fd_extra}.{fd_ext}'
             utils.write_file(filename, response.text)
 
             if not redirect:
                 data = dump.dump_all(response)
-                utils.write_file(f"debug/dumps/{fd_time}_{fd_name}{fd_extra}.{fd_ext}.dump", data.decode("utf8"))
-
-    @staticmethod
-    def get_random_user_agent() -> str:
-        windows_x64 = "Windows NT 10.0; Win64; x64"
-        linux_x64 = "X11; Linux x86_64"
-        android = []  # [f"Android {version}; Mobile" for version in range(10, 13)]
-
-        firefox_template = "Mozilla/5.0 ({osystem}; rv:{version}.0) Gecko/20100101 Firefox/{version}.0"
-        firefox_versions = range(92, 97)
-
-        chrome_template = (
-            "Mozilla/5.0 ({osystem}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{version} Safari/537.36"
-        )
-        chrome_versions = ["92.0.4515.159", "93.0.4577.82", "94.0.4606.81", "95.0.4638.54", "96.0.4664.110"]
-        uas = []
-
-        for osystem in [windows_x64, linux_x64, *android]:
-            for version in firefox_versions:
-                uas.append(firefox_template.format(osystem=osystem, version=version))
-            for version in chrome_versions:
-                uas.append(chrome_template.format(osystem=osystem, version=version))
-
-        return random.choice(uas)
+                utils.write_file(f'debug/dumps/{fd_time}_{fd_name}{fd_extra}.{fd_ext}.dump', data.decode('utf8'))
 
 
 class CitizenBaseAPI:
@@ -136,7 +122,7 @@ class CitizenBaseAPI:
     token: str
 
     def __init__(self):
-        """Class for unifying eRepublik known endpoints and their required/optional parameters"""
+        """ Class for unifying eRepublik known endpoints and their required/optional parameters """
         self._req = SlowRequests()
         self.token = ""
 
@@ -154,94 +140,75 @@ class CitizenBaseAPI:
         return self.get(self.url)
 
     def set_socks_proxy(self, host: str, port: int, username: str = None, password: str = None):
-        url = f"socks5://{username}:{password}@{host}:{port}" if username and password else f"socks5://{host}:{port}"
+        url = f'socks5://{username}:{password}@{host}:{port}' if username and password else f'socks5://{host}:{port}'
         self._req.proxies = dict(http=url, https=url)
 
     def set_http_proxy(self, host: str, port: int, username: str = None, password: str = None):
-        url = f"http://{username}:{password}@{host}:{port}" if username and password else f"http://{host}:{port}"
+        url = f'http://{username}:{password}@{host}:{port}' if username and password else f'http://{host}:{port}'
         self._req.proxies = dict(http=url)
 
     def _get_main_session_captcha(self) -> Response:
-        return self.get(f"{self.url}/main/sessionCaptcha")
+        return self.get(f'{self.url}/main/sessionCaptcha')
 
     def _get_main_session_unlock_popup(self) -> Response:
-        return self.get(f"{self.url}/main/sessionUnlockPopup")
+        return self.get(f'{self.url}/main/sessionUnlockPopup')
 
     def _post_main_session_get_challenge(self, captcha_id: int, image_id: str = "") -> Response:
-        c = [cookie.name for cookie in self._req.cookies if not cookie.has_nonstandard_attr("HttpOnly")]
-        env = dict(l=["tets"], s=[], c=c, m=0)
+        c = [cookie.name for cookie in self._req.cookies if not cookie.has_nonstandard_attr('HttpOnly')]
+        env = dict(l=['tets'], s=[], c=c, m=0)
         data = dict(_token=self.token, captchaId=captcha_id, env=utils.b64json(env))
         if image_id:
             data.update(imageId=image_id, isRefresh=True)
-        return self.post(f"{self.url}/main/sessionGetChallenge", data=data)
+        return self.post(f'{self.url}/main/sessionGetChallenge', data=data)
 
     def _post_main_session_unlock(
         self, captcha_id: int, image_id: str, challenge_id: str, coords: List[Dict[str, int]], src: str
     ) -> Response:
-        c = [cookie.name for cookie in self._req.cookies if not cookie.has_nonstandard_attr("HttpOnly")]
-        env = dict(l=["tets"], s=[], c=c, m=0)
-
-        session_hash = hashlib.sha256(",".join(env["l"] + env["s"]).encode("utf8")).hexdigest()
-        cookies_hash = hashlib.sha256(",".join(env["c"]).encode("utf8")).hexdigest()
-
-        cookie_kwargs = dict(
-            expires=int(time.time()) + 120,
-            path="/en/main/sessionUnlock",
-            domain=".www.erepublik.com",
-            secure=True,
-            rest={"HttpOnly": True},
-        )
-        self._req.cookies.set("sh", session_hash, **cookie_kwargs)
-        self._req.cookies.set("ch", cookies_hash, **cookie_kwargs)
+        c = [cookie.name for cookie in self._req.cookies if not cookie.has_nonstandard_attr('HttpOnly')]
+        env = dict(l=['tets'], s=[], c=c, m=0)
+        cookies = dict(sh=hashlib.sha256(','.join(env['l']+env['s']).encode('utf8')).hexdigest(),
+                       ch=hashlib.sha256(','.join(env['c']).encode('utf8')).hexdigest())
+        cookie_kwargs = dict(expires=int(time.time())+120, path="/en/main/sessionUnlock", domain='.www.erepublik.com',
+                             secure=True, rest={'HttpOnly': True})
+        self._req.cookies.set('sh', cookies['sh'], **cookie_kwargs)
+        self._req.cookies.set('ch', cookies['ch'], **cookie_kwargs)
         b64_env = utils.b64json(env)
-        data = dict(
-            _token=self.token,
-            captchaId=captcha_id,
-            imageId=image_id,
-            challengeId=challenge_id,
-            clickMatrix=utils.json_dumps(coords).replace(" ", ""),
-            isMobile=0,
-            env=b64_env,
-            src=src,
-        )
-        return self.post(
-            f"{self.url}/main/sessionUnlock",
-            data=data,
-            json=data,
-            headers={"X-Requested-With": "XMLHttpRequest", "Referer": "https://www.erepublik.com/en"},
-        )
+        data = dict(_token=self.token, captchaId=captcha_id, imageId=image_id, challengeId=challenge_id,
+                    clickMatrix=utils.json_dumps(coords).replace(' ', ''), isMobile=0, env=b64_env, src=src)
+        return self.post(f'{self.url}/main/sessionUnlock', data=data, json=data,
+                         headers={'X-Requested-With': 'XMLHttpRequest', 'Referer': 'https://www.erepublik.com/en'})
 
     def _post_energy_refill_get_inventory(self):
-        return self.post(f"{self.url}/economy/energyRefill-getInventory", data={"_token": self.token})
+        return self.post(f'{self.url}/economy/energyRefill-getInventory', data={'_token': self.token})
 
 
 class ErepublikAnniversaryAPI(CitizenBaseAPI):
     def _post_main_collect_anniversary_reward(self) -> Response:
-        return self.post(f"{self.url}/main/collect-anniversary-reward", data={"_token": self.token})
+        return self.post(f"{self.url}/main/collect-anniversary-reward", data={'_token': self.token})
 
     # 12th anniversary endpoints
     def _get_anniversary_quest_data(self) -> Response:
         return self.get(f"{self.url}/main/anniversaryQuestData")
 
     def _post_map_rewards_unlock(self, node_id: int) -> Response:
-        data = {"nodeId": node_id, "_token": self.token}
+        data = {'nodeId': node_id, '_token': self.token}
         return self.post(f"{self.url}/main/map-rewards-unlock", 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}
+        data = {'nodeId': node_id, '_token': self.token, 'currencyCost': currency_amount}
         return self.post(f"{self.url}/main/map-rewards-speedup", data=data)
 
     def _post_map_rewards_claim(self, node_id: int, extra: bool = False) -> Response:
-        data = {"nodeId": node_id, "_token": self.token}
+        data = {'nodeId': node_id, '_token': self.token}
         if extra:
-            data["claimExtra"] = 1
+            data['claimExtra'] = 1
         return self.post(f"{self.url}/main/map-rewards-claim", data=data)
 
     def _post_main_wheel_of_fortune_spin(self, cost) -> Response:
-        return self.post(f"{self.url}/main/wheeloffortune-spin", data={"_token": self.token, "_currentCost": cost})
+        return self.post(f"{self.url}/main/wheeloffortune-spin", data={'_token': self.token, '_currentCost': cost})
 
     def _post_main_wheel_of_fortune_build(self) -> Response:
-        return self.post(f"{self.url}/main/wheeloffortune-build", data={"_token": self.token})
+        return self.post(f"{self.url}/main/wheeloffortune-build", data={'_token': self.token})
 
 
 class ErepublikArticleAPI(CitizenBaseAPI):
@@ -254,13 +221,13 @@ class ErepublikArticleAPI(CitizenBaseAPI):
     def _post_main_article_comments(self, article_id: int, page: int = 1) -> Response:
         data = dict(_token=self.token, articleId=article_id, page=page)
         if page:
-            data.update({"page": page})
+            data.update({'page': page})
         return self.post(f"{self.url}/main/articleComments", data=data)
 
     def _post_main_article_comments_create(self, message: str, article_id: int, parent: int = 0) -> Response:
         data = dict(_token=self.token, message=message, articleId=article_id)
         if parent:
-            data.update({"parentId": parent})
+            data.update({'parentId': parent})
         return self.post(f"{self.url}/main/articleComments/create", data=data)
 
     def _post_main_donate_article(self, article_id: int, amount: int) -> Response:
@@ -268,13 +235,8 @@ class ErepublikArticleAPI(CitizenBaseAPI):
         return self.post(f"{self.url}/main/donate-article", data=data)
 
     def _post_main_write_article(self, title: str, content: str, country_id: int, kind_id: int) -> Response:
-        data = dict(
-            _token=self.token,
-            article_name=title,
-            article_body=content,
-            article_location=country_id,
-            article_category=kind_id,
-        )
+        data = dict(_token=self.token, article_name=title, article_body=content, article_location=country_id,
+                    article_category=kind_id)
         return self.post(f"{self.url}/main/write-article", data=data)
 
     def _post_main_vote_article(self, article_id: int) -> Response:
@@ -284,14 +246,13 @@ class ErepublikArticleAPI(CitizenBaseAPI):
 
 class ErepublikCompanyAPI(CitizenBaseAPI):
     def _post_economy_assign_to_holding(self, factory_id: int, holding_id: int) -> Response:
-        data = dict(_token=self.token, factoryId=factory_id, action="assign", holdingCompanyId=holding_id)
+        data = dict(_token=self.token, factoryId=factory_id, action='assign', holdingCompanyId=holding_id)
         return self.post(f"{self.url}/economy/assign-to-holding", data=data)
 
     def _post_economy_create_company(self, industry_id: int, building_type: int = 1) -> Response:
-        data = {"_token": self.token, "company[industry_id]": industry_id, "company[building_type]": building_type}
-        return self.post(
-            f"{self.url}/economy/create-company", data=data, headers={"Referer": f"{self.url}/economy/create-company"}
-        )
+        data = {'_token': self.token, "company[industry_id]": industry_id, "company[building_type]": building_type}
+        return self.post(f"{self.url}/economy/create-company", data=data,
+                         headers={'Referer': f"{self.url}/economy/create-company"})
 
     def _get_economy_inventory_items(self) -> Response:
         return self.get(f"{self.url}/economy/inventory-items/")
@@ -308,43 +269,39 @@ class ErepublikCompanyAPI(CitizenBaseAPI):
             data["grounds[%i][id]" % idx] = tg_id
             data["grounds[%i][train]" % idx] = 1
         if data:
-            data["_token"] = self.token
+            data['_token'] = self.token
         return self.post(f"{self.url}/economy/train", 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)
+        data = dict(_token=self.token, type='upgrade', companyId=factory, level=level, pin="" if pin is None else pin)
         return self.post(f"{self.url}/economy/upgrade-company", 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 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(
-                    {
+                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,
-                    }
-                )
+                    f"companies[{max_idx}][own_work]": 1
+                })
                 max_idx += 1
             for company_id in sorted(employ or []):
-                data.update(
-                    {
+                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,
-                    }
-                )
+                    f"companies[{max_idx}][own_work]": 0
+                })
                 max_idx += 1
         return self.post(f"{self.url}/economy/work", data=data)
 
     def _post_economy_work_overtime(self) -> Response:
-        data = dict(action_type="workOvertime", _token=self.token)
+        data = dict(action_type='workOvertime', _token=self.token)
         return self.post(f"{self.url}/economy/workOvertime", data=data)
 
     def _post_economy_job_market_apply(self, citizen_id: int, salary: float) -> Response:
@@ -352,32 +309,29 @@ class ErepublikCompanyAPI(CitizenBaseAPI):
         return self.post(f"{self.url}/economy/job-market-apply", data=data)
 
     def _post_economy_resign(self) -> Response:
-        return self.post(
-            f"{self.url}/economy/resign",
+        return self.post(f"{self.url}/economy/resign",
                          headers={"Content-Type": "application/x-www-form-urlencoded"},
-            data={"_token": self.token, "action_type": "resign"},
-        )
+                         data={'_token': self.token, 'action_type': 'resign'})
 
     def _post_economy_sell_company(self, factory_id: 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"})
+            data.update({'sell': 'sell'})
         else:
-            data.update({"dissolve": factory_id})
-        return self.post(f"{self.url}/economy/sell-company/{factory_id}", data=data, headers={"Referer": self.url})
+            data.update({'dissolve': factory_id})
+        return self.post(f"{self.url}/economy/sell-company/{factory_id}",
+                         data=data, headers={'Referer': self.url})
 
 
 class ErepublikCountryAPI(CitizenBaseAPI):
     def _get_country_military(self, country_name: str) -> Response:
         return self.get(f"{self.url}/country/military/{country_name}")
 
-    def _post_main_country_donate(
-        self, country_id: int, action: str, value: Union[int, float], quality: int = None
-    ) -> Response:
+    def _post_main_country_donate(self, country_id: int, action: str, value: Union[int, float],
+                                  quality: int = None) -> Response:
         data = dict(countryId=country_id, action=action, _token=self.token, value=value, quality=quality)
-        return self.post(
-            f"{self.url}/main/country-donate", data=data, headers={"Referer": f"{self.url}/country/economy/Latvia"}
-        )
+        return self.post(f"{self.url}/main/country-donate", data=data,
+                         headers={'Referer': f"{self.url}/country/economy/Latvia"})
 
 
 class ErepublikEconomyAPI(CitizenBaseAPI):
@@ -399,24 +353,20 @@ class ErepublikEconomyAPI(CitizenBaseAPI):
         return self.post(f"{self.url}/economy/activateBooster", data=data)
 
     def _post_economy_activate_house(self, quality: int) -> Response:
-        data = dict(action="activate", quality=quality, type="house", _token=self.token)
+        data = dict(action='activate', quality=quality, type='house', _token=self.token)
         return self.post(f"{self.url}/economy/activateHouse", data=data)
 
-    def _post_economy_donate_items_action(self, citizen_id: int, amount: int, industry: int, quality: int) -> Response:
+    def _post_economy_donate_items_action(self, citizen_id: int, amount: int, industry: int,
+                                          quality: int) -> Response:
         data = dict(citizen_id=citizen_id, amount=amount, industry_id=industry, quality=quality, _token=self.token)
-        return self.post(
-            f"{self.url}/economy/donate-items-action",
-            data=data,
-            headers={"Referer": f"{self.url}/economy/donate-items/{citizen_id}"},
-        )
+        return self.post(f"{self.url}/economy/donate-items-action", data=data,
+                         headers={'Referer': f"{self.url}/economy/donate-items/{citizen_id}"})
 
-    def _post_economy_donate_money_action(self, citizen_id: int, amount: float = 0.0, currency: int = 62) -> Response:
+    def _post_economy_donate_money_action(self, citizen_id: int, amount: float = 0.0,
+                                          currency: int = 62) -> Response:
         data = dict(citizen_id=citizen_id, _token=self.token, currency_id=currency, amount=amount)
-        return self.post(
-            f"{self.url}/economy/donate-money-action",
-            data=data,
-            headers={"Referer": f"{self.url}/economy/donate-money/{citizen_id}"},
-        )
+        return self.post(f"{self.url}/economy/donate-money-action", data=data,
+                         headers={'Referer': f"{self.url}/economy/donate-money/{citizen_id}"})
 
     def _post_economy_exchange_purchase(self, amount: float, currency: int, offer: int) -> Response:
         data = dict(_token=self.token, amount=amount, currencyId=currency, offerId=offer)
@@ -427,69 +377,46 @@ class ErepublikEconomyAPI(CitizenBaseAPI):
         return self.post(f"{self.url}/economy/exchange/retrieve/", data=data)
 
     def _post_economy_game_tokens_market(self, action: str) -> Response:
-        assert action in [
-            "retrieve",
-        ]
+        assert action in ['retrieve', ]
         data = dict(_token=self.token, action=action)
         return self.post(f"{self.url}/economy/gameTokensMarketAjax", 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,
-        )
+    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(f"{self.url}/economy/marketplaceAjax", data=data)
 
     def _post_economy_marketplace_actions(self, action: str, **kwargs) -> Response:
-        if action == "buy":
-            data = dict(
-                _token=self.token,
-                offerId=kwargs["offer"],
-                amount=kwargs["amount"],
-                orderBy="price_asc",
-                currentPage=1,
-                buyAction=1,
-            )
-        elif action == "sell":
-            data = dict(
-                _token=self.token,
-                countryId=kwargs["country_id"],
-                price=kwargs["price"],
-                industryId=kwargs["industry"],
-                quality=kwargs["quality"],
-                amount=kwargs["amount"],
-                sellAction="postOffer",
-            )
-        elif action == "delete":
-            data = dict(_token=self.token, offerId=kwargs["offer_id"], sellAction="deleteOffer")
+        if action == 'buy':
+            data = dict(_token=self.token, offerId=kwargs['offer'], amount=kwargs['amount'],
+                        orderBy='price_asc', currentPage=1, buyAction=1)
+        elif action == 'sell':
+            data = dict(_token=self.token, countryId=kwargs['country_id'], price=kwargs['price'],
+                        industryId=kwargs['industry'], quality=kwargs['quality'], amount=kwargs['amount'],
+                        sellAction='postOffer')
+        elif action == 'delete':
+            data = dict(_token=self.token, offerId=kwargs['offer_id'], sellAction='deleteOffer')
         else:
             raise ValueError(f"Action '{action}' is not supported! Only 'buy/sell/delete' actions are available")
         return self.post(f"{self.url}/economy/marketplaceActions", data=data)
 
 
 class ErepublikLeaderBoardAPI(CitizenBaseAPI):
-    def _get_main_leaderboards_damage_aircraft_rankings(
-        self, country_id: int, weeks: int = 0, mu_id: int = 0
-    ) -> Response:  # noqa
+    def _get_main_leaderboards_damage_aircraft_rankings(self, country_id: int, weeks: int = 0,
+                                                        mu_id: int = 0) -> Response:  # noqa
         return self.get(f"{self.url}/main/leaderboards-damage-aircraft-rankings/{country_id}/{weeks}/{mu_id}/0")
 
-    def _get_main_leaderboards_damage_rankings(
-        self, country_id: int, weeks: int = 0, mu_id: int = 0, div: int = 0
-    ) -> Response:  # noqa
+    def _get_main_leaderboards_damage_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0,
+                                               div: int = 0) -> Response:  # noqa
         return self.get(f"{self.url}/main/leaderboards-damage-rankings/{country_id}/{weeks}/{mu_id}/{div}")
 
-    def _get_main_leaderboards_kills_aircraft_rankings(
-        self, country_id: int, weeks: int = 0, mu_id: int = 0
-    ) -> Response:  # noqa
+    def _get_main_leaderboards_kills_aircraft_rankings(self, country_id: int, weeks: int = 0,
+                                                       mu_id: int = 0) -> Response:  # noqa
         return self.get(f"{self.url}/main/leaderboards-kills-aircraft-rankings/{country_id}/{weeks}/{mu_id}/0")
 
-    def _get_main_leaderboards_kills_rankings(
-        self, country_id: int, weeks: int = 0, mu_id: int = 0, div: int = 0
-    ) -> Response:  # noqa
+    def _get_main_leaderboards_kills_rankings(self, country_id: int, weeks: int = 0, mu_id: int = 0,
+                                              div: int = 0) -> Response:  # noqa
         return self.get(f"{self.url}/main/leaderboards-kills-rankings/{country_id}/{weeks}/{mu_id}/{div}")
 
 
@@ -497,7 +424,7 @@ class ErepublikLocationAPI(CitizenBaseAPI):
     def _get_main_city_data_residents(self, city_id: int, page: int = 1, params: Mapping[str, Any] = None) -> Response:
         if params is None:
             params = {}
-        return self.get(f"{self.url}/main/city-data/{city_id}/residents", params={"currentPage": page, **params})
+        return self.get(f"{self.url}/main/city-data/{city_id}/residents", params={'currentPage': page, **params})
 
 
 class ErepublikMilitaryAPI(CitizenBaseAPI):
@@ -508,7 +435,7 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
         return self.get(f"{self.url}/military/battlefield-choose-side/{battle_id}/{side_id}")
 
     def _get_military_show_weapons(self, battle_id: int) -> Response:
-        return self.get(f"{self.url}/military/show-weapons", params={"_token": self.token, "battleId": battle_id})
+        return self.get(f"{self.url}/military/show-weapons", params={'_token': self.token, 'battleId': battle_id})
 
     def _get_military_campaigns(self) -> Response:
         return self.get(f"{self.url}/military/campaigns-new/")
@@ -520,7 +447,7 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
         return self.get(f"{self.url}/military/campaignsJson/citizen")
 
     def _get_military_unit_data(self, unit_id: int, **kwargs) -> Response:
-        params = {"groupId": unit_id, "panel": "members", **kwargs}
+        params = {'groupId': unit_id, 'panel': 'members', **kwargs}
         return self.get(f"{self.url}/military/military-unit-data/", params=params)
 
     def _post_main_activate_battle_effect(self, battle_id: int, kind: str, citizen_id: int) -> Response:
@@ -544,39 +471,22 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
         data = dict(type=kind, quality=quality, duration=duration, battleId=battle_id, _token=self.token)
         return self.post(f"{self.url}/military/fight-activateBooster", data=data)
 
-    def _post_military_change_weapon(
-        self,
-        battle_id: int,
-        battle_zone: int,
-        weapon_level: int,
-    ) -> Response:
+    def _post_military_change_weapon(self, battle_id: int, battle_zone: int, weapon_level: int, ) -> Response:
         data = dict(battleId=battle_id, _token=self.token, battleZoneId=battle_zone, customizationLevel=weapon_level)
         return self.post(f"{self.url}/military/change-weapon", 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":
+        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(f"{self.url}/military/battle-console", data=data)
 
     def _post_military_deploy_bomb(self, battle_id: int, division_id: int, side_id: int, bomb_id: int) -> Response:
-        data = dict(
-            battleId=battle_id,
-            battleZoneId=division_id,
-            sideId=side_id,
-            sideCountryId=side_id,
-            bombId=bomb_id,
-            _token=self.token,
-        )
+        data = dict(battleId=battle_id, battleZoneId=division_id, sideId=side_id, sideCountryId=side_id,
+                    bombId=bomb_id, _token=self.token)
         return self.post(f"{self.url}/military/deploy-bomb", data=data)
 
     def _post_military_fight_air(self, battle_id: int, side_id: int, zone_id: int) -> Response:
@@ -598,15 +508,8 @@ class ErepublikMilitaryAPI(CitizenBaseAPI):
     def _post_fight_deploy_start_deploy(
         self, battle_id: int, side_id: int, battle_zone_id: int, energy: int, weapon: int, **kwargs
     ) -> Response:
-        data = dict(
-            _token=self.token,
-            battleId=battle_id,
-            battleZoneId=battle_zone_id,
-            sideCountryId=side_id,
-            weaponQuality=weapon,
-            totalEnergy=energy,
-            **kwargs,
-        )
+        data = dict(_token=self.token, battleId=battle_id, battleZoneId=battle_zone_id, sideCountryId=side_id,
+                    weaponQuality=weapon, totalEnergy=energy, **kwargs)
         return self.post(f"{self.url}/military/fightDeploy-startDeploy", data=data)
 
     def _post_military_fight_deploy_deploy_report_data(self, deployment_id: int) -> Response:
@@ -632,9 +535,8 @@ class ErepublikPoliticsAPI(CitizenBaseAPI):
         return self.get(f"{self.url}/main/presidential-elections/{country_id}/{timestamp}")
 
     def _post_propose_president_candidate(self, party_slug: str, citizen_id: int) -> Response:
-        return self.post(
-            f"{self.url}/propose-president-candidate/{party_slug}", data=dict(_token=self.token, citizen=citizen_id)
-        )
+        return self.post(f"{self.url}/propose-president-candidate/{party_slug}",
+                         data=dict(_token=self.token, citizen=citizen_id))
 
     def _get_auto_propose_president_candidate(self, party_slug: str) -> Response:
         return self.get(f"{self.url}/auto-propose-president-candidate/{party_slug}")
@@ -642,28 +544,17 @@ class ErepublikPoliticsAPI(CitizenBaseAPI):
 
 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(f"{self.url}/wars/attack-region/{war_id}/{region_id}", data=data)
+        data = {'_token': self.token, 'warId': war_id, 'regionName': region_name, 'regionNameConfirm': region_name}
+        return self.post(f'{self.url}/wars/attack-region/{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=constants.COUNTRIES[attack_country_id].link,
-        )
+        data = dict(requirments=1, _token=self.token, debate=debate,
+                    countryNameConfirm=constants.COUNTRIES[attack_country_id].link)
         return self.post(f"{self.url}/{constants.COUNTRIES[self_country_id].link}/new-war", 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,
-        )
+        data = dict(requirments=1, _token=self.token, debate=debate, currency=1, value=amount, commit='Propose',
+                    type_name=org_name)
         return self.post(f"{self.url}/{constants.COUNTRIES[country_id].link}/new-donation", data=data)
 
 
@@ -684,10 +575,10 @@ class ErepublikProfileAPI(CitizenBaseAPI):
         return self.get(f"{self.url}/main/messages-paginated/{page}")
 
     def _get_main_money_donation_accept(self, donation_id: int) -> Response:
-        return self.get(f"{self.url}/main/money-donation/accept/{donation_id}", params={"_token": self.token})
+        return self.get(f"{self.url}/main/money-donation/accept/{donation_id}", params={'_token': self.token})
 
     def _get_main_money_donation_reject(self, donation_id: int) -> Response:
-        return self.get(f"{self.url}/main/money-donation/reject/{donation_id}", params={"_token": self.token})
+        return self.get(f"{self.url}/main/money-donation/reject/{donation_id}", params={'_token': self.token})
 
     def _get_main_notifications_ajax_community(self, page: int = 1) -> Response:
         return self.get(f"{self.url}/main/notificationsAjax/community/{page}")
@@ -707,16 +598,16 @@ class ErepublikProfileAPI(CitizenBaseAPI):
     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"})
+            data.update({'action': 'addFriend'})
         else:
-            data.update({"action": "removeFriend"})
+            data.update({'action': 'removeFriend'})
         return self.post(f"{self.url}/main/citizen-addRemoveFriend", data=data)
 
     def _post_main_daily_task_reward(self) -> Response:
         return self.post(f"{self.url}/main/daily-tasks-reward", data=dict(_token=self.token))
 
     def _post_delete_message(self, msg_id: list) -> Response:
-        data = {"_token": self.token, "delete_message[]": msg_id}
+        data = {'_token': self.token, "delete_message[]": msg_id}
         return self.post(f"{self.url}/main/messages-delete", data)
 
     def _post_eat(self, color: str) -> Response:
@@ -728,41 +619,37 @@ class ErepublikProfileAPI(CitizenBaseAPI):
         return self.post(f"{self.url}/main/global-alerts/close", data=data)
 
     def _post_forgot_password(self, email: str) -> Response:
-        data = dict(_token=self.token, email=email, commit="Reset password")
+        data = dict(_token=self.token, email=email, commit='Reset password')
         return self.post(f"{self.url}/forgot-password", 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")
+        data = dict(csrf_token=self.token, citizen_email=email, citizen_password=password, remember='on')
         return self.post(f"{self.url}/login", 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"}
+        data = {'_token': self.token, "delete_alerts[]": notification_ids, 'deleteAllAlerts': '1', 'delete': 'Delete'}
         return self.post(f"{self.url}/main/messages-alerts/1", 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}
+        data = {'_token': self.token, "delete_alerts[]": notification_ids}
         return self.post(f"{self.url}/main/notificationsAjax/community/{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}
+        data = {'_token': self.token, "delete_alerts[]": notification_ids}
         return self.post(f"{self.url}/main/notificationsAjax/system/{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}
+        data = {'_token': self.token, "delete_alerts[]": notification_ids}
         return self.post(f"{self.url}/main/notificationsAjax/report/{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,
-        )
+        data = dict(citizen_name=",".join([str(x) for x in citizens]),
+                    citizen_subject=subject, _token=self.token, citizen_message=body)
         return self.post(f"{self.url}/main/messages-compose/{url_pk}", data=data)
 
     def _post_military_group_missions(self) -> Response:
-        data = dict(action="check", _token=self.token)
+        data = dict(action='check', _token=self.token)
         return self.post(f"{self.url}/military/group-missions", data=data)
 
     def _post_main_weekly_challenge_reward(self, reward_id: int) -> Response:
@@ -774,7 +661,7 @@ class ErepublikProfileAPI(CitizenBaseAPI):
         return self.post(f"{self.url}/main/weekly-challenge-collect-all", data=data)
 
     def _post_main_profile_update(self, action: str, params: str):
-        data = {"action": action, "params": params, "_token": self.token}
+        data = {'action': action, 'params': params, '_token': self.token}
         return self.post(f"{self.url}/main/profile-update", data=data)
 
 
@@ -791,96 +678,85 @@ class ErepublikWallPostAPI(CitizenBaseAPI):
     # ## Country
 
     def _post_main_country_comment_retrieve(self, post_id: int) -> Response:
-        data = {"_token": self.token, "postId": post_id}
+        data = {'_token': self.token, 'postId': post_id}
         return self.post(f"{self.url}/main/country-comment/retrieve/json", 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}
+        data = {'_token': self.token, 'postId': post_id, 'comment_message': comment_message}
         return self.post(f"{self.url}/main/country-comment/create/json", 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}
+        data = {'_token': self.token, 'post_message': body, 'post_as': post_as}
         return self.post(f"{self.url}/main/country-post/create/json", data=data)
 
     def _post_main_country_post_retrieve(self) -> Response:
-        data = {"_token": self.token, "page": 1, "switchedFrom": False}
+        data = {'_token': self.token, 'page': 1, 'switchedFrom': False}
         return self.post(f"{self.url}/main/country-post/retrieve/json", data=data)
 
     # ## Military Unit
 
     def _post_main_military_unit_comment_retrieve(self, post_id: int) -> Response:
-        data = {"_token": self.token, "postId": post_id}
+        data = {'_token': self.token, 'postId': post_id}
         return self.post(f"{self.url}/main/military-unit-comment/retrieve/json", 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}
+        data = {'_token': self.token, 'postId': post_id, 'comment_message': comment_message}
         return self.post(f"{self.url}/main/military-unit-comment/create/json", 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}
+        data = {'_token': self.token, 'post_message': body, 'post_as': post_as}
         return self.post(f"{self.url}/main/military-unit-post/create/json", data=data)
 
     def _post_main_military_unit_post_retrieve(self) -> Response:
-        data = {"_token": self.token, "page": 1, "switchedFrom": False}
+        data = {'_token': self.token, 'page': 1, 'switchedFrom': False}
         return self.post(f"{self.url}/main/military-unit-post/retrieve/json", data=data)
 
     # ## Party
 
     def _post_main_party_comment_retrieve(self, post_id: int) -> Response:
-        data = {"_token": self.token, "postId": post_id}
+        data = {'_token': self.token, 'postId': post_id}
         return self.post(f"{self.url}/main/party-comment/retrieve/json", 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}
+        data = {'_token': self.token, 'postId': post_id, 'comment_message': comment_message}
         return self.post(f"{self.url}/main/party-comment/create/json", data=data)
 
     def _post_main_party_post_create(self, body: str) -> Response:
-        data = {"_token": self.token, "post_message": body}
+        data = {'_token': self.token, 'post_message': body}
         return self.post(f"{self.url}/main/party-post/create/json", data=data)
 
     def _post_main_party_post_retrieve(self) -> Response:
-        data = {"_token": self.token, "page": 1, "switchedFrom": False}
+        data = {'_token': self.token, 'page': 1, 'switchedFrom': False}
         return self.post(f"{self.url}/main/party-post/retrieve/json", data=data)
 
     # ## Friend's Wall
 
     def _post_main_wall_comment_retrieve(self, post_id: int) -> Response:
-        data = {"_token": self.token, "postId": post_id}
+        data = {'_token': self.token, 'postId': post_id}
         return self.post(f"{self.url}/main/wall-comment/retrieve/json", 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}
+        data = {'_token': self.token, 'postId': post_id, 'comment_message': comment_message}
         return self.post(f"{self.url}/main/wall-comment/create/json", data=data)
 
     def _post_main_wall_post_create(self, body: str) -> Response:
-        data = {"_token": self.token, "post_message": body}
+        data = {'_token': self.token, 'post_message': body}
         return self.post(f"{self.url}/main/wall-post/create/json", data=data)
 
     def _post_main_wall_post_retrieve(self) -> Response:
-        data = {"_token": self.token, "page": 1, "switchedFrom": False}
+        data = {'_token': self.token, 'page': 1, 'switchedFrom': False}
         return self.post(f"{self.url}/main/wall-post/retrieve/json", data=data)
 
     # ## Medal posting
     def _post_main_wall_post_automatic(self, message: str, achievement_id: int) -> Response:
-        return self.post(
-            f"{self.url}/main/wall-post/automatic",
-            data=dict(_token=self.token, message=message, achievementId=achievement_id),
-        )
+        return self.post(f"{self.url}/main/wall-post/automatic", 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,
+    ErepublikArticleAPI, ErepublikCountryAPI, ErepublikCompanyAPI, ErepublikEconomyAPI,
+    ErepublikLeaderBoardAPI, ErepublikLocationAPI, ErepublikMilitaryAPI, ErepublikProfileAPI,
+    ErepublikPresidentAPI, ErepublikPoliticsAPI, ErepublikAnniversaryAPI, ErepublikWallPostAPI,
+    ErepublikTravelAPI
 ):
     pass

erepublik/constants.py

@@ -3,26 +3,10 @@ from typing import Dict, Optional, Union
 
 import pytz
 
-__all__ = [
-    "erep_tz",
-    "min_datetime",
-    "max_datetime",
-    "Country",
-    "Industries",
-    "Rank",
-    "AIR_RANKS",
-    "AIR_RANK_NAMES",
-    "AIR_RANK_POINTS",
-    "COUNTRIES",
-    "FOOD_ENERGY",
-    "GROUND_RANKS",
-    "GROUND_RANK_NAMES",
-    "GROUND_RANK_POINTS",
-    "INDUSTRIES",
-    "TERRAINS",
-]
+__all__ = ['erep_tz', 'min_datetime', 'max_datetime', 'Country', 'AIR_RANKS', 'COUNTRIES', 'FOOD_ENERGY',
+           'GROUND_RANKS', 'GROUND_RANK_POINTS', 'INDUSTRIES', 'TERRAINS']
 
-erep_tz = pytz.timezone("US/Pacific")
+erep_tz = pytz.timezone('US/Pacific')
 min_datetime = erep_tz.localize(datetime.datetime(2007, 11, 20))
 max_datetime = erep_tz.localize(datetime.datetime(2281, 9, 4))
 
@@ -69,71 +53,20 @@ class Country:
 
 
 class Industries:
-    __by_name = {
-        "food": 1,
-        "weapon": 2,
-        "ticket": 3,
-        "house": 4,
-        "aircraft": 23,
-        "foodraw": 7,
-        "weaponraw": 12,
-        "houseraw": 18,
-        "aircraftraw": 24,
-        "airplaneraw": 24,
-        "frm": 7,
-        "wrm": 12,
-        "hrm": 18,
-        "arm": 24,
-        "frm q1": 7,
-        "frm q2": 8,
-        "frm q3": 9,
-        "frm q4": 10,
-        "frm q5": 11,
-        "wrm q1": 12,
-        "wrm q2": 13,
-        "wrm q3": 14,
-        "wrm q4": 15,
-        "wrm q5": 16,
-        "hrm q1": 18,
-        "hrm q2": 19,
-        "hrm q3": 20,
-        "hrm q4": 21,
-        "hrm q5": 22,
-        "arm q1": 24,
-        "arm q2": 25,
-        "arm q3": 26,
-        "arm q4": 27,
-        "arm q5": 28,
-    }
-    __by_id = {
-        1: "Food",
-        2: "Weapon",
-        3: "Ticket",
-        4: "House",
-        23: "Aircraft",
-        7: "foodRaw",
-        8: "FRM q2",
-        9: "FRM q3",
-        10: "FRM q4",
-        11: "FRM q5",
-        12: "weaponRaw",
-        13: "WRM q2",
-        14: "WRM q3",
-        15: "WRM q4",
-        16: "WRM q5",
-        18: "houseRaw",
-        19: "HRM q2",
-        20: "HRM q3",
-        21: "HRM q4",
-        22: "HRM q5",
-        24: "aircraftRaw",
-        25: "ARM q2",
-        26: "ARM q3",
-        27: "ARM q4",
-        28: "ARM q5",
-    }
+    __by_name = {'food': 1, 'weapon': 2, 'ticket': 3, 'house': 4, 'aircraft': 23,
+                 'foodraw': 7, 'weaponraw': 12, 'houseraw': 18, 'aircraftraw': 24, 'airplaneraw': 24,
+                 'frm': 7, 'wrm': 12, 'hrm': 18, 'arm': 24,
+                 'frm q1': 7, 'frm q2': 8, 'frm q3': 9, 'frm q4': 10, 'frm q5': 11,
+                 'wrm q1': 12, 'wrm q2': 13, 'wrm q3': 14, 'wrm q4': 15, 'wrm q5': 16,
+                 'hrm q1': 18, 'hrm q2': 19, 'hrm q3': 20, 'hrm q4': 21, 'hrm q5': 22,
+                 'arm q1': 24, 'arm q2': 25, 'arm q3': 26, 'arm q4': 27, 'arm q5': 28}
+    __by_id = {1: 'Food', 2: 'Weapon', 3: 'Ticket', 4: 'House', 23: 'Aircraft',
+               7: 'foodRaw', 8: 'FRM q2', 9: 'FRM q3', 10: 'FRM q4', 11: 'FRM q5',
+               12: 'weaponRaw', 13: 'WRM q2', 14: 'WRM q3', 15: 'WRM q4', 16: 'WRM q5',
+               17: 'houseRaw', 18: 'houseRaw', 19: 'HRM q2', 20: 'HRM q3', 21: 'HRM q4', 22: 'HRM q5',
+               24: 'aircraftRaw', 25: 'ARM q2', 26: 'ARM q3', 27: 'ARM q4', 28: 'ARM q5'}
 
-    def __getitem__(self, item: Union[int, str]) -> Optional[Union[int, str]]:
+    def __getitem__(self, item) -> Optional[Union[int, str]]:
         if isinstance(item, int):
             return self.__by_id.get(item, None)
         elif isinstance(item, str):
@@ -203,10 +136,6 @@ class Rank:
     def as_dict(self):
         return dict(id=self.id, name=self.name, rank_points=self.rank_points, is_air=self.is_air)
 
-    @property
-    def __dict__(self):
-        return self.as_dict
-
     def __str__(self):
         return f"{'Air' if self.is_air else 'Ground'}Rank<#{self.id} {self.name}>"
 
@@ -215,452 +144,110 @@ class Rank:
 
 
 AIR_RANK_NAMES: 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*****",
-    62: "Air Vice Marshal",
-    63: "Air Vice Marshal*",
-    64: "Air Vice Marshal**",
-    65: "Air Vice Marshal***",
-    66: "Air Vice Marshal****",
-    67: "Air Vice Marshal*****",
-    68: "Air Marshal",
-    69: "Air Marshal*",
-    70: "Air Marshal**",
-    71: "Air Marshal***",
-    72: "Air Marshal****",
-    73: "Air Marshal*****",
-    74: "Air Chief Marshal",
-    75: "Air Chief Marshal*",
-    76: "Air Chief Marshal**",
-    77: "Air Chief Marshal***",
-    78: "Air Chief Marshal****",
-    79: "Air Chief Marshal*****",
+    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*****',
+    62: 'Air Vice Marshal', 63: 'Air Vice Marshal*', 64: 'Air Vice Marshal**', 65: 'Air Vice Marshal***', 66: 'Air Vice Marshal****', 67: 'Air Vice Marshal*****',
+    68: 'Air Marshal', 69: 'Air Marshal*', 70: 'Air Marshal**', 71: 'Air Marshal***', 72: 'Air Marshal****', 73: 'Air Marshal*****',
+    74: 'Air Chief Marshal', 75: 'Air Chief Marshal*', 76: 'Air Chief Marshal**', 77: 'Air Chief Marshal***', 78: 'Air Chief Marshal****', 79: 'Air Chief Marshal*****',
 }
 
 AIR_RANK_POINTS: Dict[int, Optional[int]] = {
-    1: 0,
-    2: 10,
-    3: 25,
-    4: 45,
-    5: 70,
-    6: 100,
-    7: 140,
-    8: 190,
-    9: 270,
-    10: 380,
-    11: 530,
-    12: 850,
-    13: 1300,
-    14: 2340,
-    15: 3300,
-    16: 4200,
-    17: 5150,
-    18: 6100,
-    19: 7020,
-    20: 9100,
-    21: 12750,
-    22: 16400,
-    23: 20000,
-    24: 23650,
-    25: 27300,
-    26: 35500,
-    27: 48000,
-    28: 60000,
-    29: 72400,
-    30: 84500,
-    31: 97000,
-    32: 110000,
-    33: 140000,
-    34: 170000,
-    35: 210000,
-    36: 290000,
-    37: 350000,
-    38: 429000,
-    39: 601000,
-    40: 772000,
-    41: 944000,
-    42: 1115000,
-    43: 1287000,
-    44: 1673000,
-    45: 2238000,
-    46: 2804000,
-    47: 3369000,
-    48: 3935000,
-    49: 4500000,
-    50: 5020000,
-    51: 7028000,
-    52: 9036000,
-    53: 11044000,
-    54: 13052000,
-    55: 15060000,
-    56: 19580000,
-    57: 27412000,
-    58: 35244000,
-    59: 43076000,
-    60: 50908000,
-    61: 58740000,
-    62: 76360000,
-    63: 113166443,
-    64: 137448000,
-    65: None,
-    66: None,
-    67: None,
-    68: None,
-    69: None,
-    70: None,
-    71: None,
-    72: None,
-    73: None,
-    74: None,
-    75: None,
-    76: None,
-    77: None,
-    78: None,
-    79: None,
+    1: 0, 2: 10, 3: 25, 4: 45, 5: 70, 6: 100, 7: 140, 8: 190, 9: 270, 10: 380, 11: 530, 12: 850, 13: 1300, 14: 2340, 15: 3300, 16: 4200, 17: 5150, 18: 6100, 19: 7020, 20: 9100, 21: 12750, 22: 16400, 23: 20000, 24: 23650, 25: 27300,
+    26: 35500, 27: 48000, 28: 60000, 29: 72400, 30: 84500, 31: 97000, 32: 110000, 33: 140000, 34: 170000, 35: 210000, 36: 290000, 37: 350000, 38: 429000, 39: 601000, 40: 772000, 41: 944000, 42: 1115000, 43: 1287000,
+    44: 1673000, 45: 2238000, 46: 2804000, 47: 3369000, 48: 3935000, 49: 4500000, 50: 5020000, 51: 7028000, 52: 9036000, 53: 11044000, 54: 13052000, 55: 15060000,
+    56: 19580000, 57: 27412000, 58: 35244000, 59: 43076000, 60: 50908000, 61: 58740000, 62: 76360000, 63: 113166443, 64: 137448000, 65: None, 66: None, 67: None,
+    68: None, 69: None, 70: None, 71: None, 72: None, 73: None, 74: None, 75: None, 76: None, 77: None, 78: None, 79: None,
 }
 
 AIR_RANKS: Dict[int, Rank] = {i: Rank(i, AIR_RANK_NAMES[i], AIR_RANK_POINTS[i], True) for i in range(1, 80)}
 
 COUNTRIES: Dict[int, Country] = {
-    1: Country(1, "Romania", "Romania", "ROU"),
-    9: Country(9, "Brazil", "Brazil", "BRA"),
-    10: Country(10, "Italy", "Italy", "ITA"),
-    11: Country(11, "France", "France", "FRA"),
-    12: Country(12, "Germany", "Germany", "DEU"),
-    13: Country(13, "Hungary", "Hungary", "HUN"),
-    14: Country(14, "China", "China", "CHN"),
-    15: Country(15, "Spain", "Spain", "ESP"),
-    23: Country(23, "Canada", "Canada", "CAN"),
-    24: Country(24, "USA", "USA", "USA"),
-    26: Country(26, "Mexico", "Mexico", "MEX"),
-    27: Country(27, "Argentina", "Argentina", "ARG"),
-    28: Country(28, "Venezuela", "Venezuela", "VEN"),
-    29: Country(29, "United Kingdom", "United-Kingdom", "GBR"),
-    30: Country(30, "Switzerland", "Switzerland", "CHE"),
-    31: Country(31, "Netherlands", "Netherlands", "NLD"),
-    32: Country(32, "Belgium", "Belgium", "BEL"),
-    33: Country(33, "Austria", "Austria", "AUT"),
-    34: Country(34, "Czech Republic", "Czech-Republic", "CZE"),
-    35: Country(35, "Poland", "Poland", "POL"),
-    36: Country(36, "Slovakia", "Slovakia", "SVK"),
-    37: Country(37, "Norway", "Norway", "NOR"),
-    38: Country(38, "Sweden", "Sweden", "SWE"),
-    39: Country(39, "Finland", "Finland", "FIN"),
-    40: Country(40, "Ukraine", "Ukraine", "UKR"),
-    41: Country(41, "Russia", "Russia", "RUS"),
-    42: Country(42, "Bulgaria", "Bulgaria", "BGR"),
-    43: Country(43, "Turkey", "Turkey", "TUR"),
-    44: Country(44, "Greece", "Greece", "GRC"),
-    45: Country(45, "Japan", "Japan", "JPN"),
-    47: Country(47, "South Korea", "South-Korea", "KOR"),
-    48: Country(48, "India", "India", "IND"),
-    49: Country(49, "Indonesia", "Indonesia", "IDN"),
-    50: Country(50, "Australia", "Australia", "AUS"),
-    51: Country(51, "South Africa", "South-Africa", "ZAF"),
-    52: Country(52, "Republic of Moldova", "Republic-of-Moldova", "MDA"),
-    53: Country(53, "Portugal", "Portugal", "PRT"),
-    54: Country(54, "Ireland", "Ireland", "IRL"),
-    55: Country(55, "Denmark", "Denmark", "DNK"),
-    56: Country(56, "Iran", "Iran", "IRN"),
-    57: Country(57, "Pakistan", "Pakistan", "PAK"),
-    58: Country(58, "Israel", "Israel", "ISR"),
-    59: Country(59, "Thailand", "Thailand", "THA"),
-    61: Country(61, "Slovenia", "Slovenia", "SVN"),
-    63: Country(63, "Croatia", "Croatia", "HRV"),
-    64: Country(64, "Chile", "Chile", "CHL"),
-    65: Country(65, "Serbia", "Serbia", "SRB"),
-    66: Country(66, "Malaysia", "Malaysia", "MYS"),
-    67: Country(67, "Philippines", "Philippines", "PHL"),
-    68: Country(68, "Singapore", "Singapore", "SGP"),
-    69: Country(69, "Bosnia and Herzegovina", "Bosnia-Herzegovina", "BiH"),
-    70: Country(70, "Estonia", "Estonia", "EST"),
-    80: Country(80, "Montenegro", "Montenegro", "MNE"),
-    71: Country(71, "Latvia", "Latvia", "LVA"),
-    72: Country(72, "Lithuania", "Lithuania", "LTU"),
-    73: Country(73, "North Korea", "North-Korea", "PRK"),
-    74: Country(74, "Uruguay", "Uruguay", "URY"),
-    75: Country(75, "Paraguay", "Paraguay", "PRY"),
-    76: Country(76, "Bolivia", "Bolivia", "BOL"),
-    77: Country(77, "Peru", "Peru", "PER"),
-    78: Country(78, "Colombia", "Colombia", "COL"),
-    79: Country(79, "Republic of Macedonia (FYROM)", "Republic-of-Macedonia-FYROM", "MKD"),
-    81: Country(81, "Republic of China (Taiwan)", "Republic-of-China-Taiwan", "TWN"),
-    82: Country(82, "Cyprus", "Cyprus", "CYP"),
-    167: Country(167, "Albania", "Albania", "ALB"),
-    83: Country(83, "Belarus", "Belarus", "BLR"),
-    84: Country(84, "New Zealand", "New-Zealand", "NZL"),
-    164: Country(164, "Saudi Arabia", "Saudi-Arabia", "SAU"),
-    165: Country(165, "Egypt", "Egypt", "EGY"),
-    166: Country(166, "United Arab Emirates", "United-Arab-Emirates", "UAE"),
-    168: Country(168, "Georgia", "Georgia", "GEO"),
-    169: Country(169, "Armenia", "Armenia", "ARM"),
-    170: Country(170, "Nigeria", "Nigeria", "NGA"),
-    171: Country(171, "Cuba", "Cuba", "CUB"),
+    1: Country(1, 'Romania', 'Romania', 'ROU'), 9: Country(9, 'Brazil', 'Brazil', 'BRA'),
+    10: Country(10, 'Italy', 'Italy', 'ITA'), 11: Country(11, 'France', 'France', 'FRA'),
+    12: Country(12, 'Germany', 'Germany', 'DEU'), 13: Country(13, 'Hungary', 'Hungary', 'HUN'),
+    14: Country(14, 'China', 'China', 'CHN'), 15: Country(15, 'Spain', 'Spain', 'ESP'),
+    23: Country(23, 'Canada', 'Canada', 'CAN'), 24: Country(24, 'USA', 'USA', 'USA'),
+    26: Country(26, 'Mexico', 'Mexico', 'MEX'), 27: Country(27, 'Argentina', 'Argentina', 'ARG'),
+    28: Country(28, 'Venezuela', 'Venezuela', 'VEN'), 29: Country(29, 'United Kingdom', 'United-Kingdom', 'GBR'),
+    30: Country(30, 'Switzerland', 'Switzerland', 'CHE'), 31: Country(31, 'Netherlands', 'Netherlands', 'NLD'),
+    32: Country(32, 'Belgium', 'Belgium', 'BEL'), 33: Country(33, 'Austria', 'Austria', 'AUT'),
+    34: Country(34, 'Czech Republic', 'Czech-Republic', 'CZE'), 35: Country(35, 'Poland', 'Poland', 'POL'),
+    36: Country(36, 'Slovakia', 'Slovakia', 'SVK'), 37: Country(37, 'Norway', 'Norway', 'NOR'),
+    38: Country(38, 'Sweden', 'Sweden', 'SWE'), 39: Country(39, 'Finland', 'Finland', 'FIN'),
+    40: Country(40, 'Ukraine', 'Ukraine', 'UKR'), 41: Country(41, 'Russia', 'Russia', 'RUS'),
+    42: Country(42, 'Bulgaria', 'Bulgaria', 'BGR'), 43: Country(43, 'Turkey', 'Turkey', 'TUR'),
+    44: Country(44, 'Greece', 'Greece', 'GRC'), 45: Country(45, 'Japan', 'Japan', 'JPN'),
+    47: Country(47, 'South Korea', 'South-Korea', 'KOR'), 48: Country(48, 'India', 'India', 'IND'),
+    49: Country(49, 'Indonesia', 'Indonesia', 'IDN'), 50: Country(50, 'Australia', 'Australia', 'AUS'),
+    51: Country(51, 'South Africa', 'South-Africa', 'ZAF'),
+    52: Country(52, 'Republic of Moldova', 'Republic-of-Moldova', 'MDA'),
+    53: Country(53, 'Portugal', 'Portugal', 'PRT'), 54: Country(54, 'Ireland', 'Ireland', 'IRL'),
+    55: Country(55, 'Denmark', 'Denmark', 'DNK'), 56: Country(56, 'Iran', 'Iran', 'IRN'),
+    57: Country(57, 'Pakistan', 'Pakistan', 'PAK'), 58: Country(58, 'Israel', 'Israel', 'ISR'),
+    59: Country(59, 'Thailand', 'Thailand', 'THA'), 61: Country(61, 'Slovenia', 'Slovenia', 'SVN'),
+    63: Country(63, 'Croatia', 'Croatia', 'HRV'), 64: Country(64, 'Chile', 'Chile', 'CHL'),
+    65: Country(65, 'Serbia', 'Serbia', 'SRB'), 66: Country(66, 'Malaysia', 'Malaysia', 'MYS'),
+    67: Country(67, 'Philippines', 'Philippines', 'PHL'), 68: Country(68, 'Singapore', 'Singapore', 'SGP'),
+    69: Country(69, 'Bosnia and Herzegovina', 'Bosnia-Herzegovina', 'BiH'),
+    70: Country(70, 'Estonia', 'Estonia', 'EST'), 80: Country(80, 'Montenegro', 'Montenegro', 'MNE'),
+    71: Country(71, 'Latvia', 'Latvia', 'LVA'), 72: Country(72, 'Lithuania', 'Lithuania', 'LTU'),
+    73: Country(73, 'North Korea', 'North-Korea', 'PRK'), 74: Country(74, 'Uruguay', 'Uruguay', 'URY'),
+    75: Country(75, 'Paraguay', 'Paraguay', 'PRY'), 76: Country(76, 'Bolivia', 'Bolivia', 'BOL'),
+    77: Country(77, 'Peru', 'Peru', 'PER'), 78: Country(78, 'Colombia', 'Colombia', 'COL'),
+    79: Country(79, 'Republic of Macedonia (FYROM)', 'Republic-of-Macedonia-FYROM', 'MKD'),
+    81: Country(81, 'Republic of China (Taiwan)', 'Republic-of-China-Taiwan', 'TWN'),
+    82: Country(82, 'Cyprus', 'Cyprus', 'CYP'), 167: Country(167, 'Albania', 'Albania', 'ALB'),
+    83: Country(83, 'Belarus', 'Belarus', 'BLR'), 84: Country(84, 'New Zealand', 'New-Zealand', 'NZL'),
+    164: Country(164, 'Saudi Arabia', 'Saudi-Arabia', 'SAU'), 165: Country(165, 'Egypt', 'Egypt', 'EGY'),
+    166: Country(166, 'United Arab Emirates', 'United-Arab-Emirates', 'UAE'),
+    168: Country(168, 'Georgia', 'Georgia', 'GEO'), 169: Country(169, 'Armenia', 'Armenia', 'ARM'),
+    170: Country(170, 'Nigeria', 'Nigeria', 'NGA'), 171: Country(171, 'Cuba', 'Cuba', 'CUB')
 }
 
 FOOD_ENERGY: Dict[str, int] = dict(q1=2, q2=4, q3=6, q4=8, q5=10, q6=12, q7=20)
 
 GROUND_RANK_NAMES: 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",
+    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,
+    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
 }
 
 GROUND_RANKS: Dict[int, Rank] = {i: Rank(i, GROUND_RANK_NAMES[i], GROUND_RANK_POINTS[i], False) for i in range(1, 90)}
 
 INDUSTRIES = Industries()
 
-TERRAINS: Dict[int, str] = {
-    0: "Standard",
-    1: "Industrial",
-    2: "Urban",
-    3: "Suburbs",
-    4: "Airport",
-    5: "Plains",
-    6: "Wasteland",
-    7: "Mountains",
-    8: "Beach",
-    9: "Swamp",
-    10: "Mud",
-    11: "Hills",
-    12: "Jungle",
-    13: "Forest",
-    14: "Desert",
-}
+TERRAINS: Dict[int, str] = {0: 'Standard', 1: 'Industrial', 2: 'Urban', 3: 'Suburbs', 4: 'Airport', 5: 'Plains',
+                            6: 'Wasteland', 7: 'Mountains', 8: 'Beach', 9: 'Swamp', 10: 'Mud', 11: 'Hills',
+                            12: 'Jungle', 13: 'Forest', 14: 'Desert'}

erepublik/utils.py

@@ -23,33 +23,10 @@ except ImportError:
     import json
 
 __all__ = [
-    "ErepublikJSONEncoder",
-    "VERSION",
-    "b64json",
-    "calculate_hit",
-    "date_from_eday",
-    "deprecation",
-    "eday_from_date",
-    "get_air_hit_dmg_value",
-    "get_file",
-    "get_final_hit_dmg",
-    "get_ground_hit_dmg_value",
-    "get_sleep_seconds",
-    "good_timedelta",
-    "interactive_sleep",
-    "json",
-    "json_decode_object_hook",
-    "json_dump",
-    "json_dumps",
-    "json_load",
-    "json_loads",
-    "localize_dt",
-    "localize_timestamp",
-    "normalize_html_json",
-    "now",
-    "silent_sleep",
-    "slugify",
-    "write_file",
+    'VERSION', 'calculate_hit', 'date_from_eday', 'eday_from_date', 'deprecation', 'get_final_hit_dmg', 'write_file',
+    'get_air_hit_dmg_value', 'get_file', 'get_ground_hit_dmg_value', 'get_sleep_seconds', 'good_timedelta', 'slugify',
+    'interactive_sleep', 'json', 'localize_dt', 'localize_timestamp', 'normalize_html_json', 'now', 'silent_sleep',
+    'json_decode_object_hook', 'json_load', 'json_loads', 'json_dump', 'json_dumps', 'b64json', 'ErepublikJSONEncoder',
 ]
 
 VERSION: str = __version__
@@ -93,12 +70,12 @@ def eday_from_date(date: Union[datetime.date, datetime.datetime] = None) -> int:
     return (date - datetime.datetime(2007, 11, 20, 0, 0, 0)).days
 
 
-def date_from_eday(eday: int) -> datetime.datetime:
+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"""
+    """ 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
 
@@ -130,7 +107,7 @@ def get_file(filepath: str) -> str:
     file = Path(filepath)
     if file.exists():
         if file.is_dir():
-            return str(file / "new_file.txt")
+            return str(file / 'new_file.txt')
         else:
             version = 1
             try:
@@ -152,16 +129,16 @@ def get_file(filepath: str) -> str:
 
 def write_file(filename: str, content: str) -> int:
     filename = get_file(filename)
-    with open(filename, "ab") as f:
+    with open(filename, 'ab') as f:
         ret = f.write(content.encode("utf-8"))
     return ret
 
 
 def normalize_html_json(js: str) -> str:
-    js = re.sub(r" \'(.*?)\'", lambda a: f'"{a.group(1)}"', js)
-    js = re.sub(r"(\d\d):(\d\d):(\d\d)", r"\1\2\3", js)
+    js = re.sub(r' \'(.*?)\'', lambda a: f'"{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)
+    js = re.sub(r',\s*}', '}', js)
     return js
 
 
@@ -174,63 +151,47 @@ def slugify(value, allow_unicode=False) -> str:
     """
     value = str(value)
     if allow_unicode:
-        value = unicodedata.normalize("NFKC", value)
+        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)
+        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:
+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))
+    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
 
     dmg = get_final_hit_dmg(dmg, rang, tp=tp, elite=elite, ne=ne, booster=booster)
     return Decimal(round(dmg, dec))
 
 
-def get_ground_hit_dmg_value(
-    citizen_id: int, natural_enemy: bool = False, true_patriot: bool = False, 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
+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
+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)
 
 
-def get_final_hit_dmg(
-    base_dmg: Union[Decimal, float, str],
-    rang: int,
-    tp: bool = False,
-    elite: bool = False,
-    ne: bool = False,
-    booster: int = 0,
-) -> Decimal:
+def get_final_hit_dmg(base_dmg: Union[Decimal, float, str], rang: int,
+                      tp: bool = False, elite: bool = False, ne: bool = False, booster: int = 0) -> Decimal:
     dmg = Decimal(str(base_dmg))
 
     if elite:
@@ -250,51 +211,51 @@ def deprecation(message):
 def json_decode_object_hook(
     o: Union[Dict[str, Any], List[Any], int, float, str]
 ) -> Union[Dict[str, Any], List[Any], int, float, str, datetime.date, datetime.datetime, datetime.timedelta]:
-    """Convert classes.ErepublikJSONEncoder datetime, date and timedelta to their python objects
+    """ Convert classes.ErepublikJSONEncoder datetime, date and timedelta to their python objects
 
     :param o:
     :return: Union[Dict[str, Any], List[Any], int, float, str, datetime.date, datetime.datetime, datetime.timedelta]
     """
-    if o.get("__type__"):
-        _type = o.get("__type__")
-        if _type == "datetime":
-            dt = datetime.datetime.strptime(f"{o['date']} {o['time']}", "%Y-%m-%d %H:%M:%S")
-            if o.get("tzinfo"):
-                dt = pytz.timezone(o["tzinfo"]).localize(dt)
+    if o.get('__type__'):
+        _type = o.get('__type__')
+        if _type == 'datetime':
+            dt = datetime.datetime.strptime(f"{o['date']} {o['time']}", '%Y-%m-%d %H:%M:%S')
+            if o.get('tzinfo'):
+                dt = pytz.timezone(o['tzinfo']).localize(dt)
             return dt
-        elif _type == "date":
-            dt = datetime.datetime.strptime(f"{o['date']}", "%Y-%m-%d")
+        elif _type == 'date':
+            dt = datetime.datetime.strptime(f"{o['date']}", '%Y-%m-%d')
             return dt.date()
-        elif _type == "timedelta":
-            return datetime.timedelta(seconds=o["total_seconds"])
+        elif _type == 'timedelta':
+            return datetime.timedelta(seconds=o['total_seconds'])
     return o
 
 
 def json_load(f, **kwargs):
-    # kwargs.update(object_hook=json_decode_object_hook)
+    kwargs.update(object_hook=json_decode_object_hook)
     return json.load(f, **kwargs)
 
 
 def json_loads(s: str, **kwargs):
-    # kwargs.update(object_hook=json_decode_object_hook)
+    kwargs.update(object_hook=json_decode_object_hook)
     return json.loads(s, **kwargs)
 
 
 def json_dump(obj, fp, *args, **kwargs):
-    if not kwargs.get("cls"):
+    if not kwargs.get('cls'):
         kwargs.update(cls=ErepublikJSONEncoder)
     return json.dump(obj, fp, *args, **kwargs)
 
 
 def json_dumps(obj, *args, **kwargs):
-    if not kwargs.get("cls"):
+    if not kwargs.get('cls'):
         kwargs.update(cls=ErepublikJSONEncoder)
     return json.dumps(obj, *args, **kwargs)
 
 
 def b64json(obj: Union[Dict[str, Union[int, List[str]]], List[str]]):
     if isinstance(obj, list):
-        return b64encode(json.dumps(obj, separators=(",", ":")).encode("utf-8")).decode("utf-8")
+        return b64encode(json.dumps(obj, separators=(',', ':')).encode('utf-8')).decode('utf-8')
     elif isinstance(obj, (int, str)):
         return obj
     elif isinstance(obj, dict):
@@ -302,38 +263,27 @@ def b64json(obj: Union[Dict[str, Union[int, List[str]]], List[str]]):
             obj[k] = b64json(v)
     else:
         from .classes import ErepublikException
-
-        raise ErepublikException(f"Unhandled object type! obj is {type(obj)}")
-    return b64encode(json.dumps(obj, separators=(",", ":")).encode("utf-8")).decode("utf-8")
+        raise ErepublikException(f'Unhandled object type! obj is {type(obj)}')
+    return b64encode(json.dumps(obj, separators=(',', ':')).encode('utf-8')).decode('utf-8')
 
 
 class ErepublikJSONEncoder(json.JSONEncoder):
     def default(self, o):
         try:
             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=str(o.tzinfo) if o.tzinfo else None,
-                )
+                return dict(__type__='datetime', date=o.strftime("%Y-%m-%d"), time=o.strftime("%H:%M:%S"),
+                            tzinfo=str(o.tzinfo) if o.tzinfo else None)
             elif isinstance(o, datetime.date):
-                return dict(__type__="date", date=o.strftime("%Y-%m-%d"))
+                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(),
-                )
+                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=dict(o.__dict__["headers"]), url=o.url, text=o.text, status_code=o.status_code)
-            elif hasattr(o, "as_dict"):
+                return dict(headers=dict(o.__dict__['headers']), url=o.url, text=o.text, status_code=o.status_code)
+            elif hasattr(o, 'as_dict'):
                 return o.as_dict
             elif isinstance(o, set):
                 return list(o)
@@ -341,7 +291,7 @@ class ErepublikJSONEncoder(json.JSONEncoder):
                 return o.to_json()
             elif isinstance(o, Logger):
                 return str(o)
-            elif hasattr(o, "__dict__"):
+            elif hasattr(o, '__dict__'):
                 return o.__dict__
             else:
                 return super().default(o)

examples/battle_launcher.py

@@ -4,18 +4,18 @@ 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": {
+    '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]},
-    },
+        124559: {"auto_attack": True, "regions": [176]}
+    }
 }
 
 
@@ -29,7 +29,7 @@ def _battle_launcher(player: Citizen):
     """
     global CONFIG
     finished_war_ids = {*[]}
-    war_data = CONFIG.get("battle_launcher", {})
+    war_data = CONFIG.get('battle_launcher', {})
     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)
@@ -40,23 +40,23 @@ def _battle_launcher(player: Citizen):
             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")
+                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["battle_launcher"].pop(war_id, None)
+                if status.get('ended', False):
+                    CONFIG['battle_launcher'].pop(war_id, None)
                     finished_war_ids.add(war_id)
                     continue
-                elif not status.get("can_attack"):
+                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))
+                        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:
@@ -91,12 +91,12 @@ def _battle_launcher(player: Citizen):
 
 # 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 = 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"):
+    if CONFIG.get('battle_launcher'):
         name = f"{player.name}-battle_launcher-{threading.active_count() - 1}"
         state_thread = threading.Thread(target=_battle_launcher, args=(player,), name=name)
         state_thread.start()

examples/eat_work_train.py

@@ -3,72 +3,71 @@ from datetime import timedelta
 from erepublik import Citizen, constants, utils
 
 CONFIG = {
-    "email": "player@email.com",
-    "password": "Pa$5w0rd!",
-    "interactive": True,
-    "debug": True,
-    "work": True,
-    "ot": True,  # Work OverTime
-    "wam": True,  # WorkAsManager
-    "train": True,
+    'email': 'player@email.com',
+    'password': 'Pa$5w0rd!',
+    'interactive': True,
+    'debug': True,
+    'work': True,
+    'ot': True,  # Work OverTime
+    'wam': True,  # WorkAsManager
+    'train': True
 }
 
 
 # noinspection DuplicatedCode
 def main():
-    player = Citizen(email=CONFIG["email"], password=CONFIG["password"], auto_login=False)
-    player.config.interactive = CONFIG["interactive"]
-    player.config.work = CONFIG["work"]
-    player.config.train = CONFIG["train"]
-    player.config.ot = CONFIG["ot"]
-    player.config.wam = CONFIG["wam"]
-    player.set_debug(CONFIG.get("debug", False))
+    player = Citizen(email=CONFIG['email'], password=CONFIG['password'], auto_login=False)
+    player.config.interactive = CONFIG['interactive']
+    player.config.work = CONFIG['work']
+    player.config.train = CONFIG['train']
+    player.config.ot = CONFIG['ot']
+    player.config.wam = CONFIG['wam']
+    player.set_debug(CONFIG.get('debug', False))
     player.login()
     now = player.now.replace(second=0, microsecond=0)
     dt_max = constants.max_datetime
     tasks = {}
     if player.config.work:
-        tasks.update({"work": now})
+        tasks.update({'work': now})
     if player.config.train:
-        tasks.update({"train": now})
+        tasks.update({'train': now})
     if player.config.ot:
-        tasks.update({"ot": now})
+        tasks.update({'ot': now})
     if player.config.wam:
-        tasks.update({"wam": now.replace(hour=14, minute=0)})
+        tasks.update({'wam': now.replace(hour=14, minute=0)})
     while True:
         try:
             player.update_all()
-            if tasks.get("work", dt_max) <= now:
+            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
+                    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})
+                tasks.update({'work': next_time})
 
-            if tasks.get("train", dt_max) <= now:
+            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})
+                tasks.update({'train': next_time})
 
-            if tasks.get("wam", dt_max) <= now:
+            if tasks.get('wam', dt_max) <= now:
                 player.write_log("Doing task: Work as manager")
                 success = player.work_as_manager()
                 if success:
-                    next_time = utils.good_timedelta(
-                        now.replace(hour=14, minute=0, second=0, microsecond=0), timedelta(days=1)
-                    )
+                    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})
+                tasks.update({'wam': next_time})
 
-            if tasks.get("ot", dt_max) <= now:
+            if tasks.get('ot', dt_max) <= now:
                 player.update_job_info()
                 player.write_log("Doing task: work overtime")
                 if now > player.my_companies.next_ot_time:
@@ -76,7 +75,7 @@ def main():
                     next_time = now + timedelta(minutes=60)
                 else:
                     next_time = player.my_companies.next_ot_time
-                tasks.update({"ot": next_time})
+                tasks.update({'ot': next_time})
 
             closest_next_time = dt_max
             next_tasks = []
@@ -88,9 +87,8 @@ def main():
             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(
-                f"Sleeping until (eRep): {closest_next_time.strftime('%F %T')}" f" (sleeping for {sleep_seconds}s)"
-            )
+            player.write_log(f"Sleeping until (eRep): {closest_next_time.strftime('%F %T')}"
+                             f" (sleeping for {sleep_seconds}s)")
             seconds_to_sleep = sleep_seconds if sleep_seconds > 0 else 0
             player.sleep(seconds_to_sleep)
         except Exception as e:

pyproject.toml

@@ -1,11 +0,0 @@
-[tool.black]
-line-length = 120
-target-version = ['py38', 'py39']
-extend-exclude = 'venv'
-workers = 4
-
-
-[tool.isort]
-profile = "black"
-multi_line_output = 3
-line_length = 120

requirements-dev.txt

@@ -1,16 +0,0 @@
--r requirements.txt
--r requirements-tests.txt
-bump2version==1.0.1
-coverage==6.3.2
-edx-sphinx-theme==3.0.0
-flake8==4.0.1
-ipython>=8.1.1
-jedi!=0.18.0
-isort==5.10.1
-pre-commit==2.17.0
-pur==6.0.1
-responses==0.18.0
-Sphinx==4.4.0
-twine==3.8.0
-wheel==0.37.1
-black==22.1.0

requirements-tests.txt

@@ -1,2 +0,0 @@
--r requirements.txt
-pytest==7.0.1

requirements.txt

@@ -1,4 +0,0 @@
-PySocks==1.7.1
-pytz>2021.0
-requests>2.25.0,!=2.27.0
-requests-toolbelt==0.9.1

requirements_dev.txt

@@ -0,0 +1,21 @@
+bump2version==1.0.1
+coverage==5.5
+edx-sphinx-theme==3.0.0
+flake8==3.9.2
+ipython>=7.25.0
+jedi!=0.18.0
+isort==5.9.2
+pip==21.1.3
+pre-commit==2.13.0
+pur==5.4.2
+PyInstaller==4.3
+PySocks==1.7.1
+pytest==6.2.4
+pytz==2021.1
+requests==2.25.1
+requests-toolbelt==0.9.1
+responses==0.13.3
+setuptools==57.1.0
+Sphinx==4.0.3
+twine==3.4.1
+wheel==0.36.2

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.29.2.3
+current_version = 0.25.0.4
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)\.?(?P<dev>\d+)?
@@ -7,29 +7,27 @@ serialize = {major}.{minor}.{patch}.{dev}
 	{major}.{minor}.{patch}
 
 [bumpversion:file:setup.py]
-search = version="{current_version}"
-replace = version="{new_version}"
+search = version='{current_version}'
+replace = version='{new_version}'
 
 [bumpversion:file:erepublik/__init__.py]
-search = __version__ = "{current_version}"
-replace = __version__ = "{new_version}"
+search = __version__ = '{current_version}'
+replace = __version__ = '{new_version}'
 
 [bdist_wheel]
 universal = 1
 
 [flake8]
 exclude = docs,.git,log,debug,venv
-line_length = 120
-max-line-length = 120
-ignore = D100,D101,D102,D103,E203
+max-line-length = 240
+ignore = D100,D101,D102,D103
 
 [pycodestyle]
-line_length = 140
-max-line-length = 140
+max-line-length = 240
 exclude = .git,log,debug,venv, build
 
 [mypy]
-python_version = 3.9
+python_version = 3.8
 check_untyped_defs = True
 ignore_missing_imports = False
 warn_unused_ignores = True
@@ -38,4 +36,4 @@ warn_unused_configs = True
 
 [isort]
 multi_line_output = 2
-line_length = 120
+line_length = 240

setup.py

@@ -5,50 +5,52 @@
 
 from setuptools import find_packages, setup
 
-with open("README.rst") as readme_file:
+with open('README.rst') as readme_file:
     readme = readme_file.read()
 
-with open("HISTORY.rst") as history_file:
+with open('HISTORY.rst') as history_file:
     history = history_file.read()
 
-with open("requirements.txt") as requirements_file:
-    requirements = requirements_file.read()
-    requirements = requirements.split()
+requirements = [
+    'PySocks>=1.7.1',
+    'pytz>=2021.1',
+    'requests>=2.25.0',
+    'requests-toolbelt>=0.9.0',
+]
 
 setup_requirements = []
 
-with open("requirements-tests.txt") as test_req_file:
-    test_requirements = test_req_file.read()
-    test_requirements = [
-        line.strip() for line in test_requirements.split() if line.strip()[:2].strip() not in ("#", "-r")
-    ]
+test_requirements = [
+    "pytest==6.2.4",
+    "responses==0.13.3"
+]
 
 setup(
     author="Eriks Karls",
-    author_email="eriks@72.lv",
+    author_email='eriks@72.lv',
     classifiers=[
-        "Development Status :: 4 - Beta",
-        "Intended Audience :: Developers",
-        "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
-        "Natural Language :: English",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
+        'Development Status :: 4 - Beta',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Natural Language :: English',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
     ],
     description="Python package for automated eRepublik playing",
     entry_points={},
     install_requires=requirements,
-    license="GPLv3",
-    long_description=readme + "\n\n" + history,
+    license="MIT license",
+    long_description=readme + '\n\n' + history,
     include_package_data=True,
-    keywords="erepublik",
-    name="eRepublik",
-    packages=find_packages(include=["erepublik"]),
-    python_requires=">=3.8, <4",
+    keywords='erepublik',
+    name='eRepublik',
+    packages=find_packages(include=['erepublik']),
+    python_requires='>=3.8, <4',
     setup_requires=setup_requirements,
-    test_suite="tests",
+    test_suite='tests',
     tests_require=test_requirements,
-    url="https://github.com/eeriks/erepublik/",
-    version="0.29.2.3",
+    url='https://github.com/eeriks/erepublik/',
+    version='0.25.0.4',
     zip_safe=False,
 )

tests/test_erepublik_script.py

@@ -3,10 +3,10 @@
 
 """Tests for `erepublik` package."""
 
-import unittest
-
 from erepublik import Citizen
 
+import unittest
+
 
 class TestErepublik(unittest.TestCase):
     """Tests for `erepublik` package."""
@@ -17,123 +17,121 @@ class TestErepublik(unittest.TestCase):
         self.citizen.config.interactive = False
 
     def test_should_do_levelup(self):
-        self.citizen.energy.energy = 5950
+        self.citizen.energy.recovered = 1900
+        self.citizen.energy.recoverable = 2940
         self.citizen.energy.interval = 30
-        self.citizen.energy.limit = 6000
+        self.citizen.energy.limit = 3000
         self.citizen.details.xp = 14850
         self.assertTrue(self.citizen.should_do_levelup)
 
-        self.citizen.energy.energy = 1000
+        self.citizen.energy.recoverable = 1000
         self.assertFalse(self.citizen.should_do_levelup)
 
-    # def deprecated_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.energy = 5960
-    #     self.citizen.energy.interval = 30
-    #     self.citizen.energy.limit = 6000
-    #     self.citizen.details.xp = 14850
-    #     self.assertTrue(self.citizen.should_travel_to_fight())
-    #     self.citizen.details.xp = 15000
-    #     self.citizen.energy.energy = 5000
-    #     self.assertFalse(self.citizen.should_travel_to_fight())
-    #
-    #     self.citizen.energy.energy = 5910
-    #     self.assertTrue(self.citizen.should_travel_to_fight())
-    #     self.citizen.energy.energy = 5900
-    #     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 = 10000
-    #     self.citizen.details.next_pp = [5000, 5250, 5750, 6250, 6750]
-    #     self.citizen.details.pp = 4900
-    #     self.citizen.energy.energy = 8510
-    #     self.assertEqual(self.citizen.next_reachable_energy, 850)
-    #     self.citizen.energy.energy = 8490
-    #     self.assertTrue(self.citizen.should_travel_to_fight())
-    #     self.assertEqual(self.citizen.next_reachable_energy, 350)
-    #     self.citizen.energy.energy = 250
-    #     self.assertFalse(self.citizen.should_travel_to_fight())
-    #     self.assertEqual(self.citizen.next_reachable_energy, 0)
-    #
-    # def deprecated_test_should_fight(self):
-    #     def is_wc_close():
-    #         return self.citizen.max_time_till_full_ff > self.citizen.time_till_week_change
-    #
-    #     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
-    #     if not is_wc_close:
-    #         self.assertEqual(self.citizen.should_fight(), (0, "Level up", False))
-    #
-    #         self.citizen.energy.energy = 5950
-    #         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.energy = 4000
-    #         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 = 10000
-    #         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.energy = 5910
-    #         self.assertEqual(self.citizen.should_fight(), (30, "Fighting for 1h energy. Doing 30 hits", True))
+    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):
+        def is_wc_close():
+            return self.citizen.max_time_till_full_ff > self.citizen.time_till_week_change
+        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
+        if not is_wc_close:
+            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))