Format source code using black

src/rival_regions_wrapper/__init__.py

@@ -1,4 +1,3 @@
-
 """
 Rival Regions Wrapper
 
@@ -12,7 +11,7 @@ import pathlib2
 from appdirs import user_data_dir
 
 
-DATA_DIR = user_data_dir('rival_regions_wrapper', 'bergc')
+DATA_DIR = user_data_dir("rival_regions_wrapper", "bergc")
 pathlib2.Path(DATA_DIR).mkdir(parents=True, exist_ok=True)
 
 # get logger
@@ -20,7 +19,7 @@ LOGGER = logging.getLogger(__name__)
 LOGGER.setLevel(logging.DEBUG)
 
 # create file handler
-FILE_HANDLER = logging.FileHandler('{}/output.log'.format(DATA_DIR))
+FILE_HANDLER = logging.FileHandler("{}/output.log".format(DATA_DIR))
 FILE_HANDLER.setLevel(logging.DEBUG)
 
 # create console handler
@@ -28,10 +27,13 @@ STREAM_HANDLER = logging.StreamHandler()
 STREAM_HANDLER.setLevel(logging.INFO)
 
 # create formatter and add it to the handlers
-STREAM_FORMATTER = logging.Formatter('%(name)s - %(module)s - %(levelname)s - %(message)s')
+STREAM_FORMATTER = logging.Formatter(
+    "%(name)s - %(module)s - %(levelname)s - %(message)s"
+)
 STREAM_HANDLER.setFormatter(STREAM_FORMATTER)
-FILE_FORMATTER = logging \
-        .Formatter('%(asctime)s - %(name)s - %(module)s - %(levelname)s - %(message)s')
+FILE_FORMATTER = logging.Formatter(
+    "%(asctime)s - %(name)s - %(module)s - %(levelname)s - %(message)s"
+)
 FILE_HANDLER.setFormatter(FILE_FORMATTER)
 
 # add the handlers to logger

src/rival_regions_wrapper/api.py

@@ -6,12 +6,15 @@ import time
 
 from rival_regions_wrapper import LOGGER
 from rival_regions_wrapper.cookie_handler import CookieHandler
-from rival_regions_wrapper.exceptions import SessionExpireException, \
-        NoLogginException
+from rival_regions_wrapper.exceptions import (
+    SessionExpireException,
+    NoLogginException,
+)
 
 
 def session_handler(func):
     """Handle expired sessions"""
+
     def wrapper(*args, **kwargs):
         instance = args[0]
         return try_run(instance, func, *args, **kwargs)
@@ -19,169 +22,189 @@ def session_handler(func):
     def try_run(instance, func, *args, **kwargs):
         try:
             return func(*args, **kwargs)
-        except (SessionExpireException, ConnectionError, ConnectionResetError):
+        except (
+            SessionExpireException,
+            ConnectionError,
+            ConnectionResetError,
+        ):
             CookieHandler.remove_cookie(instance.username)
             instance.login()
             return try_run(instance, func, *args, **kwargs)
         except NoLogginException:
             instance.login()
             return try_run(instance, func, *args, **kwargs)
+
     return wrapper
 
+
 def check_response(response):
     """Check resonse for authentication"""
     if not isinstance(response, str):
         response = response.text
-    if "Session expired, please, reload the page" in response or \
-            'window.location="https://rivalregions.com";' in response:
+    if (
+        "Session expired, please, reload the page" in response
+        or 'window.location="https://rivalregions.com";' in response
+    ):
         raise SessionExpireException()
 
+
 @session_handler
 def get(middleware, path, add_var_c=False):
     """Send get request to Rival Regions"""
-    if path[0] == '/':
+    if path[0] == "/":
         path = path[1:]
 
     params = {}
     if add_var_c:
-        params['c'] = middleware.authentication_handler.var_c
+        params["c"] = middleware.authentication_handler.var_c
 
     LOGGER.info(
-            '"%s": GET: "%s" var_c: %s', middleware.username, path, add_var_c
-        )
+        '"%s": GET: "%s" var_c: %s', middleware.username, path, add_var_c
+    )
     if middleware.authentication_handler.session:
         response = middleware.authentication_handler.session.get(
-            url='https://rivalregions.com/{}'.format(path),
-            params=params
+            url="https://rivalregions.com/{}".format(path), params=params
         )
         check_response(response)
     else:
         raise NoLogginException()
     return response.text
 
+
 @session_handler
 def post(middleware, path, data=None):
     """Send post request to Rival Regions"""
-    if path[0] == '/':
+    if path[0] == "/":
         path = path[1:]
     if not data:
         data = {}
-    data['c'] = middleware.authentication_handler.var_c
+    data["c"] = middleware.authentication_handler.var_c
 
     LOGGER.info('"%s": POST: "%s"', middleware.username, path)
     if middleware.authentication_handler.session:
         response = middleware.authentication_handler.session.post(
-            "https://rivalregions.com/{}".format(path),
-            data=data
+            "https://rivalregions.com/{}".format(path), data=data
         )
         check_response(response)
     else:
         raise NoLogginException()
     return response.text
 
+
 @session_handler
 def conference_message(middleware, conference_id, message):
     """Send conference message"""
     browser = middleware.authentication_handler.get_browser()
     try:
-        browser.go_to('https://rivalregions.com/#slide/conference/{}'
-                .format(conference_id)
+        browser.go_to(
+            "https://rivalregions.com/#slide/conference/{}".format(
+                conference_id
             )
+        )
         browser.refresh()
         time.sleep(2)
 
         character_count = 0
         tmp_messages = []
-        for sentence in message.split('\n'):
+        for sentence in message.split("\n"):
             sentence_character_count = 0
             tmp_sentence = []
-            for word in sentence.split(' '):
+            for word in sentence.split(" "):
                 sentence_character_count += len(word) + 1
                 if sentence_character_count >= 899:
-                    message = '{}\n{}'.format('\n'.join(
-                            tmp_messages),
-                            ' '.join(tmp_sentence)
-                        )
-                    LOGGER.info('"%s": CONF "%s": next message length: %s',
-                            middleware.username, conference_id, len(message)
-                        )
-                    browser.type(message, id='message')
-                    browser.click(id='chat_send')
+                    message = "{}\n{}".format(
+                        "\n".join(tmp_messages), " ".join(tmp_sentence)
+                    )
+                    LOGGER.info(
+                        '"%s": CONF "%s": next message length: %s',
+                        middleware.username,
+                        conference_id,
+                        len(message),
+                    )
+                    browser.type(message, id="message")
+                    browser.click(id="chat_send")
                     sentence_character_count = 0
                     tmp_sentence = []
                     character_count = 0
                     tmp_messages = []
                 tmp_sentence.append(word)
 
-            sentence = ' '.join(tmp_sentence)
+            sentence = " ".join(tmp_sentence)
             character_count += len(sentence) + 1
             if character_count >= 900:
-                message = '\n'.join(tmp_messages)
-                LOGGER.info('"%s": CONF "%s": next message length: %s',
-                        middleware.username, conference_id, len(message)
-                    )
-                browser.type(message, id='message')
-                browser.click(id='chat_send')
+                message = "\n".join(tmp_messages)
+                LOGGER.info(
+                    '"%s": CONF "%s": next message length: %s',
+                    middleware.username,
+                    conference_id,
+                    len(message),
+                )
+                browser.type(message, id="message")
+                browser.click(id="chat_send")
                 character_count = 0
                 tmp_messages = []
             tmp_messages.append(sentence)
 
         if tmp_messages:
-            message = '\n'.join(tmp_messages)
-            LOGGER.info('"%s": CONF "%s": next message length: %s',
-                    middleware.username, conference_id, len(message)
-                )
-            browser.type(message, id='message')
-            browser.click(id='chat_send')
-
-        LOGGER.info('"%s": CONF "%s": finished sending message',
-                middleware.username, conference_id
+            message = "\n".join(tmp_messages)
+            LOGGER.info(
+                '"%s": CONF "%s": next message length: %s',
+                middleware.username,
+                conference_id,
+                len(message),
             )
+            browser.type(message, id="message")
+            browser.click(id="chat_send")
+
+        LOGGER.info(
+            '"%s": CONF "%s": finished sending message',
+            middleware.username,
+            conference_id,
+        )
     finally:
         browser.close_current_tab()
 
+
 @session_handler
 def conference_notification(middleware, conference_id, message, sound):
     """Send conference notification"""
     data = {
-            'sound': 1 if sound else 0,
-            'text': message,
-            'c': middleware.authentication_handler.var_c,
-        }
+        "sound": 1 if sound else 0,
+        "text": message,
+        "c": middleware.authentication_handler.var_c,
+    }
 
     response = middleware.post(
-            "https://rivalregions.com/rival/konffcm/{}/".format(
-                conference_id
-            ),
-            data=data
-        )
+        "https://rivalregions.com/rival/konffcm/{}/".format(conference_id),
+        data=data,
+    )
     check_response(response)
-    LOGGER.info('"%s": CONF: id %s send notification ',
-            middleware.username,
-            conference_id
-        )
+    LOGGER.info(
+        '"%s": CONF: id %s send notification ',
+        middleware.username,
+        conference_id,
+    )
     return response
 
+
 @session_handler
 def conference_change_title(middleware, conference_id, title):
     """Change conference title"""
     data = {
-            't': title,
-            'c': middleware.authentication_handler.var_c,
-        }
+        "t": title,
+        "c": middleware.authentication_handler.var_c,
+    }
     response = middleware.post(
-            "https://rivalregions.com/rival/changename/{}/".format(
-                conference_id
-            ),
-            data=data
-        )
+        "https://rivalregions.com/rival/changename/{}/".format(conference_id),
+        data=data,
+    )
     check_response(response)
-    LOGGER.info('"%s": CONF: id %s changed title',
-            middleware.username,
-            conference_id
-        )
+    LOGGER.info(
+        '"%s": CONF: id %s changed title', middleware.username, conference_id
+    )
     return response
 
+
 @session_handler
 def profile_message(middleware, profile_id, message):
     """send personal message"""
@@ -189,36 +212,38 @@ def profile_message(middleware, profile_id, message):
     browser = middleware.authentication_handler.get_browser()
     try:
         browser.go_to(
-                'https://rivalregions.com/#messages/{}'.format(profile_id)
-            )
+            "https://rivalregions.com/#messages/{}".format(profile_id)
+        )
         browser.refresh()
         time.sleep(2)
-        browser.type(message, id='message')
-        browser.click(id='chat_send')
-        LOGGER.info('"%s:" PM: user id %s, finished sending message',
-                middleware.username,
-                profile_id
-            )
+        browser.type(message, id="message")
+        browser.click(id="chat_send")
+        LOGGER.info(
+            '"%s:" PM: user id %s, finished sending message',
+            middleware.username,
+            profile_id,
+        )
     finally:
         browser.close_current_tab()
 
+
 @session_handler
 def language_message(middleware, language, message):
     """Send message in language chat"""
     browser = middleware.authentication_handler.get_browser()
     try:
         browser.go_to(
-                'https://rivalregions.com/#slide/chat/lang_{}'.format(
-                        language
-                    )
-            )
+            "https://rivalregions.com/#slide/chat/lang_{}".format(language)
+        )
         browser.refresh()
         time.sleep(2)
-        browser.type(message, id='message')
-        browser.click(id='chat_send')
+        browser.type(message, id="message")
+        browser.click(id="chat_send")
 
-        LOGGER.info('"%s": CHAT: language %s, finished sending message',
-                middleware.username, language
-            )
+        LOGGER.info(
+            '"%s": CHAT: language %s, finished sending message',
+            middleware.username,
+            language,
+        )
     finally:
         browser.close_current_tab()

src/rival_regions_wrapper/authentication_handler.py

@@ -10,26 +10,32 @@ from python_anticaptcha import AnticaptchaClient
 from rival_regions_wrapper import LOGGER, DATA_DIR, login_methods
 from rival_regions_wrapper.cookie_handler import CookieHandler
 from rival_regions_wrapper.browser import Browser
-from rival_regions_wrapper.exceptions import InvalidLoginMethodException, \
-        NoLogginException, NoCookieException
+from rival_regions_wrapper.exceptions import (
+    InvalidLoginMethodException,
+    NoLogginException,
+    NoCookieException,
+)
 
 
 LOGIN_METHOD_DICT = {
-    'g': login_methods.login_google,
-    'google': login_methods.login_google,
-    'v': login_methods.login_vk,
-    'vk': login_methods.login_vk,
-    'f': login_methods.login_facebook,
-    'facebook': login_methods.login_facebook,
+    "g": login_methods.login_google,
+    "google": login_methods.login_google,
+    "v": login_methods.login_vk,
+    "vk": login_methods.login_vk,
+    "f": login_methods.login_facebook,
+    "facebook": login_methods.login_facebook,
 }
 
 
 class AuthenticationHandler:
     """class for RR client"""
+
     def __init__(self, show_window=False, captcha_key=None):
-        LOGGER.info('Initialize, show window: "%s", captcha key: "%s"',
-                show_window, bool(captcha_key)
-            )
+        LOGGER.info(
+            'Initialize, show window: "%s", captcha key: "%s"',
+            show_window,
+            bool(captcha_key),
+        )
         self.show_window = show_window
         if captcha_key:
             self.captcha_client = AnticaptchaClient(captcha_key)
@@ -43,9 +49,9 @@ class AuthenticationHandler:
 
     def set_credentials(self, login_method, username, password):
         """Set the credentials"""
-        LOGGER.info('"%s": setting credentials, method: "%s"',
-                username, login_method
-            )
+        LOGGER.info(
+            '"%s": setting credentials, method: "%s"', username, login_method
+        )
         if login_method not in LOGIN_METHOD_DICT:
             raise InvalidLoginMethodException()
         self.login_method = login_method
@@ -58,13 +64,12 @@ class AuthenticationHandler:
         LOGGER.info('"%s": start authentication', self.username)
         cookies = CookieHandler.get_cookies(self.username)
         if not cookies:
-            LOGGER.info('"%s": No (valid) cookie found, start new login',
-                    self.username
-                )
+            LOGGER.info(
+                '"%s": No (valid) cookie found, start new login',
+                self.username,
+            )
             cookies = self.login()
-            LOGGER.info('"%s": storing cookie',
-                    self.username
-                )
+            LOGGER.info('"%s": storing cookie', self.username)
             CookieHandler.write_cookies(self.username, cookies)
 
         self.session = cfscrape.CloudflareScraper()
@@ -72,7 +77,7 @@ class AuthenticationHandler:
             self.session.cookies.set(**cookie)
 
         LOGGER.debug('"%s": set the var_c', self.username)
-        response = self.session.get('https://rivalregions.com/#overview')
+        response = self.session.get("https://rivalregions.com/#overview")
         lines = response.text.split("\n")
         for line in lines:
             if re.match("(.*)var c_html(.*)", line):
@@ -83,24 +88,26 @@ class AuthenticationHandler:
     def login(self):
         """Login"""
         browser = LOGIN_METHOD_DICT[self.login_method](
-                self.show_window,
-                self.username,
-                self.password,
-                self.captcha_client
-            )
+            self.show_window,
+            self.username,
+            self.password,
+            self.captcha_client,
+        )
 
         cookies = []
-        for cookie_name in ['PHPSESSID', 'rr_f']:
+        for cookie_name in ["PHPSESSID", "rr_f"]:
             browser_cookie = browser.get_cookie(cookie_name)
             if browser_cookie:
-                LOGGER.info('"%s": Get "%s" cookie',
-                        self.username, cookie_name
-                    )
-                cookies.append(CookieHandler.create_cookie(
+                LOGGER.info(
+                    '"%s": Get "%s" cookie', self.username, cookie_name
+                )
+                cookies.append(
+                    CookieHandler.create_cookie(
                         cookie_name,
-                        browser_cookie.get('expiry', None),
-                        browser_cookie.get('value', None)
-                    ))
+                        browser_cookie.get("expiry", None),
+                        browser_cookie.get("value", None),
+                    )
+                )
             else:
                 raise NoCookieException()
 
@@ -108,17 +115,15 @@ class AuthenticationHandler:
         browser.close_current_tab()
         return cookies
 
-
     def get_browser(self):
         """Get browser"""
         if not self.session:
             raise NoLogginException()
 
         browser = Browser(self.show_window, DATA_DIR, self.username)
-        browser.go_to('https://rivalregions.com/')
-        for cookie_name, value in \
-                self.session.cookies.get_dict().items():
+        browser.go_to("https://rivalregions.com/")
+        for cookie_name, value in self.session.cookies.get_dict().items():
             browser.add_cookie(
-                    CookieHandler.create_cookie(cookie_name, None, value)
-                )
+                CookieHandler.create_cookie(cookie_name, None, value)
+            )
         return browser

src/rival_regions_wrapper/browser.py

@@ -10,19 +10,22 @@ import webbot
 
 class Browser(webbot.Browser):
     """Browser class"""
-    def __init__(self, show_window=True, data_dir='chrome', username='Profile 1'):
+
+    def __init__(
+        self, show_window=True, data_dir="chrome", username="Profile 1"
+    ):
 
         options = webdriver.ChromeOptions()
         options.add_argument("--disable-dev-shm-usage")
         options.add_argument("--no-sandbox")
-        options.add_argument('--disable-web-security')
-        options.add_argument('--allow-running-insecure-content')
+        options.add_argument("--disable-web-security")
+        options.add_argument("--allow-running-insecure-content")
         options.add_argument("user-agent=DN")
         options.add_argument("--disable-blink-features=AutomationControlled")
         options.add_experimental_option(
-                "excludeSwitches", ["enable-automation"]
-            )
-        options.add_experimental_option('useAutomationExtension', False)
+            "excludeSwitches", ["enable-automation"]
+        )
+        options.add_experimental_option("useAutomationExtension", False)
         options.add_argument("--user-data-dir={}/chrome".format(data_dir))
         options.add_argument("--profile-directory={}".format(username))
 
@@ -33,29 +36,48 @@ class Browser(webbot.Browser):
         self.Key = Keys
         self.errors = []
         stealth(
-                self.driver,
-                languages=["en-US", "en"],
-                vendor="Google Inc.",
-                platform="Win32",
-                webgl_vendor="Intel Inc.",
-                renderer="Intel Iris OpenGL Engine",
-                fix_hairline=True,
-            )
+            self.driver,
+            languages=["en-US", "en"],
+            vendor="Google Inc.",
+            platform="Win32",
+            webgl_vendor="Intel Inc.",
+            renderer="Intel Iris OpenGL Engine",
+            fix_hairline=True,
+        )
 
         for function in [
-                    'add_cookie', 'delete_all_cookies', 'delete_cookie',
-                    'execute_script', 'execute_async_script',
-                    'fullscreen_window', 'get_cookie', 'get_cookies',
-                    'get_log', 'get_network_conditions',
-                    'get_screenshot_as_base64', 'get_screenshot_as_file',
-                    'get_screenshot_as_png', 'get_window_position',
-                    'get_window_rect', 'get_window_size', 'maximize_window',
-                    'minimize_window', 'implicitly_wait', 'quit', 'refresh',
-                    'save_screenshot', 'set_network_conditions',
-                    'set_page_load_timeout', 'set_script_timeout',
-                    'set_window_position', 'set_window_rect', 'start_client',
-                    'start_session', 'stop_client', 'switch_to_alert'
-                ]:
+            "add_cookie",
+            "delete_all_cookies",
+            "delete_cookie",
+            "execute_script",
+            "execute_async_script",
+            "fullscreen_window",
+            "get_cookie",
+            "get_cookies",
+            "get_log",
+            "get_network_conditions",
+            "get_screenshot_as_base64",
+            "get_screenshot_as_file",
+            "get_screenshot_as_png",
+            "get_window_position",
+            "get_window_rect",
+            "get_window_size",
+            "maximize_window",
+            "minimize_window",
+            "implicitly_wait",
+            "quit",
+            "refresh",
+            "save_screenshot",
+            "set_network_conditions",
+            "set_page_load_timeout",
+            "set_script_timeout",
+            "set_window_position",
+            "set_window_rect",
+            "start_client",
+            "start_session",
+            "stop_client",
+            "switch_to_alert",
+        ]:
             setattr(self, function, getattr(self.driver, function))
 
     def add_cookie(self, cookie):

src/rival_regions_wrapper/cookie_handler.py

@@ -8,15 +8,18 @@ import json
 from rival_regions_wrapper import LOGGER, DATA_DIR
 
 
-class CookieHandler():
+class CookieHandler:
     """Cookie handler class"""
+
     @classmethod
     def write_cookies(cls, username, passed_cookies):
         """Write cookie to file"""
         LOGGER.info('"%s": Saving cookie', username)
         cookies = None
         try:
-            with open('{}/cookies.json'.format(DATA_DIR), 'r') as cookies_file:
+            with open(
+                "{}/cookies.json".format(DATA_DIR), "r"
+            ) as cookies_file:
                 cookies = json.load(cookies_file)
             if not cookies:
                 raise FileNotFoundError
@@ -25,12 +28,12 @@ class CookieHandler():
         if username not in cookies:
             cookies[username] = {}
         for cookie in passed_cookies:
-            cookies[username][cookie['name']] = {
-                'expiry': cookie['expires'],
-                'value': cookie['value'],
+            cookies[username][cookie["name"]] = {
+                "expiry": cookie["expires"],
+                "value": cookie["value"],
             }
 
-        with open('{}/cookies.json'.format(DATA_DIR), 'w+') as cookies_file:
+        with open("{}/cookies.json".format(DATA_DIR), "w+") as cookies_file:
             json.dump(cookies, cookies_file)
         LOGGER.info('"%s": Saved cookie', username)
 
@@ -40,25 +43,29 @@ class CookieHandler():
         LOGGER.info('"%s": Searching for cookie', username)
         cookies = []
         try:
-            with open('{}/cookies.json'.format(DATA_DIR), 'r') as cookies_file:
+            with open(
+                "{}/cookies.json".format(DATA_DIR), "r"
+            ) as cookies_file:
                 cookies_data = json.load(cookies_file)
                 for cookie_username, user_cookies in cookies_data.items():
                     if cookie_username == username:
                         LOGGER.info('"%s": Found cookie', username)
                         for cookie_name, cookie in user_cookies.items():
                             expires = datetime.fromtimestamp(
-                                    int(cookie['expiry'])
-                                )
+                                int(cookie["expiry"])
+                            )
                             if datetime.now() >= expires:
                                 LOGGER.info(
-                                        '"%s": Cookie is expired', username
-                                    )
+                                    '"%s": Cookie is expired', username
+                                )
                                 return cookies
-                            cookies.append(cls.create_cookie(
-                                cookie_name,
-                                cookie['expiry'],
-                                cookie['value'],
-                            ))
+                            cookies.append(
+                                cls.create_cookie(
+                                    cookie_name,
+                                    cookie["expiry"],
+                                    cookie["value"],
+                                )
+                            )
                         return cookies
         except FileNotFoundError:
             pass
@@ -70,12 +77,14 @@ class CookieHandler():
         LOGGER.info('"%s": Removing cookie', username)
         cookies = None
         try:
-            with open('{}/cookies.json'.format(DATA_DIR), 'r') as cookies_file:
+            with open(
+                "{}/cookies.json".format(DATA_DIR), "r"
+            ) as cookies_file:
                 cookies = json.load(cookies_file)
         except FileNotFoundError:
             cookies = {}
         cookies.pop(username, None)
-        with open('{}/cookies.json'.format(DATA_DIR), 'w+') as cookies_file:
+        with open("{}/cookies.json".format(DATA_DIR), "w+") as cookies_file:
             json.dump(cookies, cookies_file)
         LOGGER.info('"%s": Removed cookie', username)
 
@@ -83,10 +92,10 @@ class CookieHandler():
     def create_cookie(name, expiry, value):
         """Create cookie"""
         return {
-            'domain': 'rivalregions.com',
-            'name': name,
-            'path': '/',
-            'secure': False,
-            'expires': expiry,
-            'value': value,
+            "domain": "rivalregions.com",
+            "name": name,
+            "path": "/",
+            "secure": False,
+            "expires": expiry,
+            "value": value,
         }

src/rival_regions_wrapper/exceptions.py

@@ -7,48 +7,55 @@ from rival_regions_wrapper import LOGGER
 
 class InvalidLoginMethodException(Exception):
     """Raise exception when login method is invalid"""
+
     def __init__(self, *args, **kwargs):
         Exception.__init__(self, *args, **kwargs)
-        LOGGER.warning('Login method invalid')
+        LOGGER.warning("Login method invalid")
 
 
 class RRClientException(Exception):
     """RR exception"""
+
     def __init__(self, *args, **kwargs):
         Exception.__init__(self, *args, **kwargs)
-        LOGGER.warning('RRClientException')
+        LOGGER.warning("RRClientException")
 
 
 class SessionExpireException(Exception):
     """Raise when session has expired"""
+
     def __init__(self, *args, **kwargs):
         Exception.__init__(self, *args, **kwargs)
-        LOGGER.warning('Session has expired')
+        LOGGER.warning("Session has expired")
 
 
 class NoLogginException(Exception):
     """Raise exception when client isn't logged in"""
+
     def __init__(self, *args, **kwargs):
         Exception.__init__(self, *args, **kwargs)
-        LOGGER.warning('Not logged in')
+        LOGGER.warning("Not logged in")
 
 
 class NoCookieException(Exception):
     """Raise exception when there is no cookie found"""
+
     def __init__(self, *args, **kwargs):
         Exception.__init__(self, *args, **kwargs)
-        LOGGER.warning('No cookie found')
+        LOGGER.warning("No cookie found")
 
 
 class NoCaptchaClientException(Exception):
     """Raise exception when captcha client is missing"""
+
     def __init__(self, *args, **kwargs):
         Exception.__init__(self, *args, **kwargs)
-        LOGGER.warning('No Captcha client given')
+        LOGGER.warning("No Captcha client given")
 
 
 class LoginException(Exception):
     """Raise exception when there is an error during login"""
+
     def __init__(self, *args, **kwargs):
         Exception.__init__(self, *args, **kwargs)
-        LOGGER.warning('Error during login')
+        LOGGER.warning("Error during login")

src/rival_regions_wrapper/login_methods.py

@@ -8,21 +8,23 @@ from selenium.common.exceptions import NoSuchElementException
 
 from rival_regions_wrapper import LOGGER, DATA_DIR
 from rival_regions_wrapper.browser import Browser
-from rival_regions_wrapper.exceptions import NoCaptchaClientException, \
-        LoginException
+from rival_regions_wrapper.exceptions import (
+    NoCaptchaClientException,
+    LoginException,
+)
 
 
 # This should be working
 def login_google(show_window, username, password, captcha_client=None):
     """login using Google"""
-    browser = Browser(show_window, DATA_DIR, 'g_{}'.format(username))
+    browser = Browser(show_window, DATA_DIR, "g_{}".format(username))
     LOGGER.info('Google: "%s": Login start', username)
     try:
         # browser = Browser(show_window, DATA_DIR, 'g_{}'.format(username))
-        browser.go_to('https://rivalregions.com/')
+        browser.go_to("https://rivalregions.com/")
         google_login_link = browser.driver.find_element_by_css_selector(
-                '.sa_link.gogo'
-            ).get_attribute('href')
+            ".sa_link.gogo"
+        ).get_attribute("href")
         browser.go_to(google_login_link)
         time.sleep(0.5)
     except NoSuchElementException:
@@ -31,31 +33,31 @@ def login_google(show_window, username, password, captcha_client=None):
 
     # browser.get_screenshot_as_file('test_1.png')
 
-    if browser.driver.find_elements_by_css_selector('#gold'):
+    if browser.driver.find_elements_by_css_selector("#gold"):
         LOGGER.info('Google: "%s": account already logged in', username)
         return browser
 
     LOGGER.info('Google: "%s": Typing in username', username)
-    if not browser.driver.find_elements_by_css_selector('#Email'):
+    if not browser.driver.find_elements_by_css_selector("#Email"):
         LOGGER.info('Google: "%s": problem with fill in password', username)
         raise LoginException() from NoSuchElementException
-    browser.type(username, css_selector='#Email')
+    browser.type(username, css_selector="#Email")
 
     # browser.get_screenshot_as_file('test_2.png')
 
     LOGGER.info('Google: "%s": pressing next button', username)
-    browser.click(css_selector='#next')
+    browser.click(css_selector="#next")
     time.sleep(0.5)
 
     # browser.get_screenshot_as_file('test_3.png')
 
-    while browser.driver.find_elements_by_css_selector('#captcha-box'):
+    while browser.driver.find_elements_by_css_selector("#captcha-box"):
         LOGGER.info('Google: "%s": Captcha present', username)
         if not captcha_client:
             raise NoCaptchaClientException()
-        captcha_url = browser \
-                .find_elements(css_selector='#captcha-img img')[0] \
-                .get_attribute('src')
+        captcha_url = browser.find_elements(css_selector="#captcha-img img")[
+            0
+        ].get_attribute("src")
         LOGGER.debug('Google: "%s": Captcha url: "%s"', username, captcha_url)
         image = requests.get(captcha_url, stream=True).raw
         image.decode_content = True
@@ -63,28 +65,27 @@ def login_google(show_window, username, password, captcha_client=None):
         job = captcha_client.createTask(ImageToTextTask(image))
         LOGGER.info('Google: "%s": Start solve captcha', username)
         job.join()
-        LOGGER.info('Google: "%s": captcha: "%s"',
-                username, job.get_captcha_text()
-            )
+        LOGGER.info(
+            'Google: "%s": captcha: "%s"', username, job.get_captcha_text()
+        )
         browser.type(
-                job.get_captcha_text(),
-                css_selector='#identifier-captcha-input'
-            )
-        browser.click(css_selector='#next')
+            job.get_captcha_text(), css_selector="#identifier-captcha-input"
+        )
+        browser.click(css_selector="#next")
         time.sleep(0.5)
 
         # browser.get_screenshot_as_file('test_4.png')
 
-    if not browser.driver.find_elements_by_css_selector('#password'):
+    if not browser.driver.find_elements_by_css_selector("#password"):
         LOGGER.info('Google: "%s": browser security issue', username)
         if show_window:
-            browser.new_tab('https://accounts.google.com/')
+            browser.new_tab("https://accounts.google.com/")
             LOGGER.info('Google: "%s": fill in credentials', username)
-            while not browser.driver.find_elements_by_css_selector('#gold'):
+            while not browser.driver.find_elements_by_css_selector("#gold"):
                 time.sleep(2)
-                LOGGER.info('Google: "%s": waiting to fill in credentials',
-                        username
-                    )
+                LOGGER.info(
+                    'Google: "%s": waiting to fill in credentials', username
+                )
                 browser.go_to(google_login_link)
             return browser
         raise LoginException()
@@ -93,12 +94,12 @@ def login_google(show_window, username, password, captcha_client=None):
     #     source.write(browser.get_page_source())
 
     LOGGER.info('Google: "%s": Typing in password', username)
-    browser.type(password, css_selector='input')
+    browser.type(password, css_selector="input")
 
     # browser.get_screenshot_as_file('test_5.png')
 
     LOGGER.info('Google: "%s": pressing sign in button', username)
-    browser.click(css_selector='#submit')
+    browser.click(css_selector="#submit")
     time.sleep(0.5)
 
     # browser.get_screenshot_as_file('test_6.png')
@@ -109,33 +110,32 @@ def login_google(show_window, username, password, captcha_client=None):
 # IDK if this is working
 def login_vk(show_window, username, password, captcha_client=None):
     """login using VK"""
-    browser = Browser(show_window, DATA_DIR, 'vk_{}'.format(username))
-    LOGGER.info('Login method VK')
-    browser.go_to('https://rivalregions.com/')
-    browser.click(css_selector='.sa_sn.imp.float_left')
+    browser = Browser(show_window, DATA_DIR, "vk_{}".format(username))
+    LOGGER.info("Login method VK")
+    browser.go_to("https://rivalregions.com/")
+    browser.click(css_selector=".sa_sn.imp.float_left")
     time.sleep(1)
 
-    browser.type(username, into='email')
+    browser.type(username, into="email")
     browser.type(
-            password,
-            xpath="/html/body/div/div/div/div[2]/form/div/div/input[7]"
+        password, xpath="/html/body/div/div/div/div[2]/form/div/div/input[7]"
     )
-    browser.click('Log in')
+    browser.click("Log in")
     return browser
 
 
 # IDK if this is working
 def login_facebook(show_window, username, password, captcha_client=None):
     """login using Facebook"""
-    browser = Browser(show_window, DATA_DIR, 'fb_{}'.format(username))
-    LOGGER.info('Login method Facebook')
-    browser.go_to('https://rivalregions.com/')
-    browser.click(css_selector='sa_sn.float_left.imp.vkvk')
+    browser = Browser(show_window, DATA_DIR, "fb_{}".format(username))
+    LOGGER.info("Login method Facebook")
+    browser.go_to("https://rivalregions.com/")
+    browser.click(css_selector="sa_sn.float_left.imp.vkvk")
     time.sleep(1)
 
-    browser.type(username, into='Email')
-    browser.type(password, into='Password')
-    browser.click('Log In')
+    browser.type(username, into="Email")
+    browser.type(password, into="Password")
+    browser.click("Log In")
     time.sleep(5)
-    browser.click(css_selector='.sa_sn.imp.float_left')
+    browser.click(css_selector=".sa_sn.imp.float_left")
     return browser

src/rival_regions_wrapper/middleware.py

@@ -10,6 +10,7 @@ from rival_regions_wrapper.authentication_handler import AuthenticationHandler
 
 class MiddlewareBase(ABC):
     """Middleware abstract base class"""
+
     username = None
 
     @abstractmethod
@@ -23,18 +24,19 @@ class MiddlewareBase(ABC):
 
 class LocalAuthentication(MiddlewareBase):
     """Local authentication"""
+
     def __init__(self, show_window=False, captcha_client=None):
         super().__init__()
         self.authentication_handler = AuthenticationHandler(
-                show_window, captcha_client
-            )
+            show_window, captcha_client
+        )
 
     def set_credentials(self, username, password, login_method):
         """Set login credentials"""
         self.username = username
         self.authentication_handler.set_credentials(
-                login_method, username, password
-            )
+            login_method, username, password
+        )
         return self
 
     def get(self, path, add_var_c=False):
@@ -48,24 +50,23 @@ class LocalAuthentication(MiddlewareBase):
 
 class RemoteAuthentication(MiddlewareBase):
     """Remote authentication"""
+
     def __init__(self, api_url, authentication_key):
         super().__init__()
         self.api_url = api_url
-        self.headers = {
-            'Authorization': authentication_key
-        }
+        self.headers = {"Authorization": authentication_key}
 
     def get(self, path, add_var_c=False):
         """Send get requests"""
         try:
             response = requests.get(
-                '{}{}'.format(self.api_url, path), headers=self.headers
+                "{}{}".format(self.api_url, path), headers=self.headers
             )
             return response.text
         except requests.exceptions.Timeout:
-            print('timeout')
+            print("timeout")
         except requests.exceptions.RequestException as exception:
-            print('request exception')
+            print("request exception")
             raise SystemExit(exception) from exception
         return None
 
@@ -73,12 +74,12 @@ class RemoteAuthentication(MiddlewareBase):
         """Send post request"""
         try:
             response = requests.post(
-                '{}{}'.format(self.api_url, path), headers=self.headers
+                "{}{}".format(self.api_url, path), headers=self.headers
             )
             return response.text
         except requests.exceptions.Timeout:
-            print('timeout')
+            print("timeout")
         except requests.exceptions.RequestException as exception:
-            print('request exception')
+            print("request exception")
             raise SystemExit(exception) from exception
         return None

src/rival_regions_wrapper/util.py

@@ -9,39 +9,39 @@ from dateutil import parser
 
 
 ITEM_KEYS = {
-    'oil': 3,
-    'ore': 4,
-    'uranium': 11,
-    'diamonds': 15,
-    'liquid_oxygen': 21,
-    'helium-3': 24,
-    'rivalium': 26,
-    'antirad': 13,
-    'energy_drink': 17,
-    'spacerockets': 20,
-    'lss': 25,
-    'tanks': 2,
-    'aircrafts': 1,
-    'missiles': 14,
-    'bombers': 16,
-    'battleships': 18,
-    'laser_drones': 27,
-    'moon_tanks': 22,
-    'space_stations': 23
+    "oil": 3,
+    "ore": 4,
+    "uranium": 11,
+    "diamonds": 15,
+    "liquid_oxygen": 21,
+    "helium-3": 24,
+    "rivalium": 26,
+    "antirad": 13,
+    "energy_drink": 17,
+    "spacerockets": 20,
+    "lss": 25,
+    "tanks": 2,
+    "aircrafts": 1,
+    "missiles": 14,
+    "bombers": 16,
+    "battleships": 18,
+    "laser_drones": 27,
+    "moon_tanks": 22,
+    "space_stations": 23,
 }
 
 
 def parse_date(date_string):
     """Try to parse any string to date"""
     date_string = date_string.lower()
-    if 'yesterday' in date_string:
-        time = re.search(r'\d\d:\d\d', date_string)
+    if "yesterday" in date_string:
+        time = re.search(r"\d\d:\d\d", date_string)
         date = parser.parse(time.group(0)) - timedelta(days=1)
-    elif 'today' in date_string:
-        time = re.search(r'\d\d:\d\d', date_string)
+    elif "today" in date_string:
+        time = re.search(r"\d\d:\d\d", date_string)
         date = parser.parse(time.group(0))
-    elif 'tomorrow' in date_string:
-        time = re.search(r'\d\d:\d\d', date_string)
+    elif "tomorrow" in date_string:
+        time = re.search(r"\d\d:\d\d", date_string)
         date = parser.parse(time.group(0)) + timedelta(days=1)
     else:
         date = parser.parse(date_string)

src/rival_regions_wrapper/wrapper/abstract_wrapper.py

@@ -7,5 +7,6 @@ from abc import ABC
 
 class AbstractWrapper(ABC):
     """abstract base class for wrappers"""
+
     def __init__(self, middleware):
         self.middleware = middleware

src/rival_regions_wrapper/wrapper/article.py

@@ -11,13 +11,14 @@ from rival_regions_wrapper.wrapper.abstract_wrapper import AbstractWrapper
 
 class Article(AbstractWrapper):
     """Wrapper class for article"""
+
     def info(self, article_id):
         """Get artcile"""
-        path = 'news/show/{}'.format(article_id)
+        path = "news/show/{}".format(article_id)
         response = self.middleware.get(path)
-        soup = BeautifulSoup(response, 'html.parser')
+        soup = BeautifulSoup(response, "html.parser")
 
-        links = soup.select('.newspaper_links')
+        links = soup.select(".newspaper_links")
         if len(links) >= 3:
             newspaper = links[0]
             author = links[1]
@@ -27,39 +28,39 @@ class Article(AbstractWrapper):
             region = links[1]
             newspaper = None
 
-        news_content = soup.select_one('.news_content')
+        news_content = soup.select_one(".news_content")
 
         article_info = {
-            'article_id': article_id,
-            'article_title': unicodedata.normalize(
-                "NFKD", soup.select_one('.title_totr').text
+            "article_id": article_id,
+            "article_title": unicodedata.normalize(
+                "NFKD", soup.select_one(".title_totr").text
             ),
-            'author_name': re.sub(r',\s\skarma.*$', '', author.text),
-            'author_id': int(author['action'].replace('slide/profile/', '')),
-            'region_name': region.text,
-            'region_id': int(region['action'].replace('map/details/', '')),
-            'content_text': news_content.get_text(separator="\n", strip=True),
-            'content_html': news_content.prettify(),
-            'rating': int(soup.select_one('#news_number').text),
-            'comments': int(soup.select_one('.news_comments_link').text)
+            "author_name": re.sub(r",\s\skarma.*$", "", author.text),
+            "author_id": int(author["action"].replace("slide/profile/", "")),
+            "region_name": region.text,
+            "region_id": int(region["action"].replace("map/details/", "")),
+            "content_text": news_content.get_text(separator="\n", strip=True),
+            "content_html": news_content.prettify(),
+            "rating": int(soup.select_one("#news_number").text),
+            "comments": int(soup.select_one(".news_comments_link").text),
         }
 
         if newspaper:
-            article_info['newspaper_id'] = int(
-                    newspaper['action'].replace('newspaper/show/', '')
-                )
-            article_info['newspaper_name'] = newspaper.text
+            article_info["newspaper_id"] = int(
+                newspaper["action"].replace("newspaper/show/", "")
+            )
+            article_info["newspaper_name"] = newspaper.text
         else:
-            article_info['newspaper_id'] = None
-            article_info['newspaper_name'] = None
+            article_info["newspaper_id"] = None
+            article_info["newspaper_name"] = None
 
-        result = re.search(r'.+(\s.+,)', soup.select_one('.tc.small').text)
+        result = re.search(r".+(\s.+,)", soup.select_one(".tc.small").text)
         try:
-            article_info['language'] = re.sub(r'\s|,', '', result[1].strip())
+            article_info["language"] = re.sub(r"\s|,", "", result[1].strip())
         except IndexError:
             pass
 
-        date_element = soup.select_one('.news_conent_title')
-        date_string = date_element.text.replace('✘', '').strip()
-        article_info['post_date'] = util.parse_date(date_string)
+        date_element = soup.select_one(".news_conent_title")
+        date_string = date_element.text.replace("✘", "").strip()
+        article_info["post_date"] = util.parse_date(date_string)
         return article_info

src/rival_regions_wrapper/wrapper/conference.py

@@ -6,43 +6,39 @@ from rival_regions_wrapper.wrapper.abstract_wrapper import AbstractWrapper
 
 class Conference(AbstractWrapper):
     """Wrapper class for confernce"""
+
     def __init__(self, middleware, conference_id):
         AbstractWrapper.__init__(self, middleware)
         self.conference_id = conference_id
 
     def message(self, message):
         """Send message to conference"""
-        LOGGER.info('"%s": CONF "%s": start send message',
-                self.middleware.username,
-                self.conference_id
-            )
-        api.conference_message(
-                self.middleware,
-                self.conference_id,
-                message
-            )
+        LOGGER.info(
+            '"%s": CONF "%s": start send message',
+            self.middleware.username,
+            self.conference_id,
+        )
+        api.conference_message(self.middleware, self.conference_id, message)
 
     def notification(self, message, sound):
         """Send notification to conference"""
-        LOGGER.info('"%s": CONF: %s notification',
-                self.middleware.username,
-                self.conference_id
-            )
+        LOGGER.info(
+            '"%s": CONF: %s notification',
+            self.middleware.username,
+            self.conference_id,
+        )
         return api.conference_notification(
-                self.middleware,
-                self.conference_id,
-                message,
-                sound
-            )
+            self.middleware, self.conference_id, message, sound
+        )
 
     def change_title(self, title):
         """Change title of conference"""
-        LOGGER.info('"%s": CONF: %s change title: %s',
-                self.middleware.username,
-                self.conference_id, title
-            )
+        LOGGER.info(
+            '"%s": CONF: %s change title: %s',
+            self.middleware.username,
+            self.conference_id,
+            title,
+        )
         return api.conference_change_title(
-                self.middleware,
-                self.conference_id,
-                title
-            )
+            self.middleware, self.conference_id, title
+        )

src/rival_regions_wrapper/wrapper/craft.py

@@ -10,36 +10,35 @@ from rival_regions_wrapper.wrapper.abstract_wrapper import AbstractWrapper
 
 class Craft(AbstractWrapper):
     """Wrapper class for crafting"""
+
     def info(self, item):
         """Get craft"""
         if isinstance(item, str) and item in util.ITEM_KEYS:
             item = util.ITEM_KEYS[item]
-        path = 'storage/produce/{}'.format(item)
+        path = "storage/produce/{}".format(item)
         response = self.middleware.get(path)
-        soup = BeautifulSoup(response, 'html.parser')
-        resources = soup.select_one('.storage_produce_exp')
+        soup = BeautifulSoup(response, "html.parser")
+        resources = soup.select_one(".storage_produce_exp")
         resource_dict = {
-            'cash': 'white',
-            'oil': 'oil',
-            'ore': 'ore',
-            'uranium': 'uranium',
-            'diamond': 'diamond',
-            'oxygen': 'oxygen',
+            "cash": "white",
+            "oil": "oil",
+            "ore": "ore",
+            "uranium": "uranium",
+            "diamond": "diamond",
+            "oxygen": "oxygen",
         }
         resource_cost = {}
         for name, selector in resource_dict.items():
             element = resources.select_one(
-                    '.{} .produce_discount'.format(selector)
-                )
+                ".{} .produce_discount".format(selector)
+            )
             if element:
-                resource_cost[name] = int(
-                    re.sub(r'-|\.', '', element.text)
-                )
+                resource_cost[name] = int(re.sub(r"-|\.", "", element.text))
         craft = {
-            'market_price': int(
-                re.sub(r'\.|\s\$', '', soup.select('.small .imp')[1].text)
+            "market_price": int(
+                re.sub(r"\.|\s\$", "", soup.select(".small .imp")[1].text)
             ),
-            'resources': resource_cost
+            "resources": resource_cost,
         }
         return craft
 
@@ -47,7 +46,5 @@ class Craft(AbstractWrapper):
         """Craft item"""
         if isinstance(item, str) and item in util.ITEM_KEYS:
             item = util.ITEM_KEYS[item]
-        self.middleware.post(
-                'storage/newproduce/{}/{}'.format(item, amount)
-            )
+        self.middleware.post("storage/newproduce/{}/{}".format(item, amount))
         return True

src/rival_regions_wrapper/wrapper/language_chat.py

@@ -6,18 +6,14 @@ from rival_regions_wrapper.wrapper.abstract_wrapper import AbstractWrapper
 
 class LanguageChat(AbstractWrapper):
     """Wrapper class for language chat"""
+
     def __init__(self, middleware, language):
         AbstractWrapper.__init__(self, middleware)
         self.language = language
 
     def message(self, message):
         """send message to language chat"""
-        LOGGER.info('"%s": CHAT: language %s',
-                self.middleware.username,
-                self.language
-            )
-        api.language_message(
-                self.middleware,
-                self.language,
-                message
-            )
+        LOGGER.info(
+            '"%s": CHAT: language %s', self.middleware.username, self.language
+        )
+        api.language_message(self.middleware, self.language, message)

src/rival_regions_wrapper/wrapper/market.py

@@ -10,29 +10,37 @@ from rival_regions_wrapper.wrapper.abstract_wrapper import AbstractWrapper
 
 class Market(AbstractWrapper):
     """Wrapper class for profile"""
+
     def info(self, resource):
         """Get profile"""
         if isinstance(resource, str) and resource in util.ITEM_KEYS:
             resource = util.ITEM_KEYS[resource]
-        path = 'storage/listed/{}'.format(resource)
+        path = "storage/listed/{}".format(resource)
         response = self.middleware.get(path)
-        soup = BeautifulSoup(response, 'html.parser')
+        soup = BeautifulSoup(response, "html.parser")
 
-        offers_tree = soup.find_all(class_='list_link')
+        offers_tree = soup.find_all(class_="list_link")
         offers = []
         for offer_tree in offers_tree:
-            offers.append({
-                'player_id': int(re.sub(
-                        r'^.*\/', '',
-                        offer_tree.select_one('.results_date')['action']
-                    )
-                ),
-                'player_name': offer_tree.select_one('.results_date').string,
-                'price': int(
-                    float(offer_tree.select('.list_level')[1]['rat'])*100
-                ),
-                'amount': int(
-                    offer_tree.select_one('.list_level.imp.small')['rat']
-                ),
-            })
+            offers.append(
+                {
+                    "player_id": int(
+                        re.sub(
+                            r"^.*\/",
+                            "",
+                            offer_tree.select_one(".results_date")["action"],
+                        )
+                    ),
+                    "player_name": offer_tree.select_one(
+                        ".results_date"
+                    ).string,
+                    "price": int(
+                        float(offer_tree.select(".list_level")[1]["rat"])
+                        * 100
+                    ),
+                    "amount": int(
+                        offer_tree.select_one(".list_level.imp.small")["rat"]
+                    ),
+                }
+            )
         return offers

src/rival_regions_wrapper/wrapper/overview.py

@@ -8,38 +8,39 @@ from rival_regions_wrapper.wrapper.perks import Perks
 
 class Overview(AbstractWrapper):
     """Wrapper class for perks"""
+
     def info(self):
-        """Get overview """
-        path = 'main/content'
+        """Get overview"""
+        path = "main/content"
         response = self.middleware.get(path)
-        soup = BeautifulSoup(response, 'html.parser')
+        soup = BeautifulSoup(response, "html.parser")
         perks = Perks.info_parse(soup)
-        auto_war = soup.select_one('.war_index_war span.pointer:nth-child(4)')
-        if auto_war and auto_war.has_attr('action'):
-            auto_war = auto_war['action'].replace('war/details/', '')
+        auto_war = soup.select_one(".war_index_war span.pointer:nth-child(4)")
+        if auto_war and auto_war.has_attr("action"):
+            auto_war = auto_war["action"].replace("war/details/", "")
         else:
             auto_war = None
         overview = {
-            'perks': perks,
-            'war': {
-                'auto_war': auto_war,
-            }
+            "perks": perks,
+            "war": {
+                "auto_war": auto_war,
+            },
         }
         return overview
 
     def status(self):
         """Get current status"""
-        path = 'main'
+        path = "main"
         response = self.middleware.get(path)
-        soup = BeautifulSoup(response, 'html.parser')
-        profile_url = soup.select_one('#header_my_avatar')['action']
-        party_url = soup.select_one('#party_menu_members')['action']
+        soup = BeautifulSoup(response, "html.parser")
+        profile_url = soup.select_one("#header_my_avatar")["action"]
+        party_url = soup.select_one("#party_menu_members")["action"]
         stats = {
-            'profile_id': int(profile_url.replace('slide/profile/', '')),
-            'party_id': int(party_url.replace('listed/party/', '')),
-            'gold': int(soup.select_one('#g').text.replace('.', '')),
-            'money': int(soup.select_one('#m').text.replace('.', '')),
-            'level': int(soup.select_one('#exp_level').text),
-            'exp': int(soup.select_one('#exp_points').text),
+            "profile_id": int(profile_url.replace("slide/profile/", "")),
+            "party_id": int(party_url.replace("listed/party/", "")),
+            "gold": int(soup.select_one("#g").text.replace(".", "")),
+            "money": int(soup.select_one("#m").text.replace(".", "")),
+            "level": int(soup.select_one("#exp_level").text),
+            "exp": int(soup.select_one("#exp_points").text),
         }
         return stats

src/rival_regions_wrapper/wrapper/perks.py

@@ -10,62 +10,65 @@ from rival_regions_wrapper.wrapper.abstract_wrapper import AbstractWrapper
 
 class Perks(AbstractWrapper):
     """Wrapper class for perks"""
+
     def info(self):
         """Get perks"""
-        path = 'main/content'
+        path = "main/content"
         response = self.middleware.get(path)
-        soup = BeautifulSoup(response, 'html.parser')
+        soup = BeautifulSoup(response, "html.parser")
         return self.info_parse(soup)
 
     @staticmethod
     def info_parse(soup):
         """Parse perk info"""
-        perks = soup.select('.perk_source_4')
+        perks = soup.select(".perk_source_4")
         upgrade_perk = None
         upgrade_date = None
         for perk in perks:
-            date_string = perk.select_one('.small')
+            date_string = perk.select_one(".small")
             if date_string:
-                upgrade_perk = int(perk['perk'])
+                upgrade_perk = int(perk["perk"])
                 date_string = re.sub(
-                        r'^.*:\s', '',
-                        soup.select_one('.perk_source_4 .small').text
-                    )
+                    r"^.*:\s",
+                    "",
+                    soup.select_one(".perk_source_4 .small").text,
+                )
                 upgrade_date = util.parse_date(date_string)
                 break
         perks = {
-            'strenght': int(
-                soup.find('div', {'perk': 1, 'class': 'perk_source_2'}).text
+            "strenght": int(
+                soup.find("div", {"perk": 1, "class": "perk_source_2"}).text
             ),
-            'education': int(
-                soup.find('div', {'perk': 2, 'class': 'perk_source_2'}).text
+            "education": int(
+                soup.find("div", {"perk": 2, "class": "perk_source_2"}).text
             ),
-            'endurance': int(
-                soup.find('div', {'perk': 3, 'class': 'perk_source_2'}).text
+            "endurance": int(
+                soup.find("div", {"perk": 3, "class": "perk_source_2"}).text
             ),
-            'upgrade_date': upgrade_date,
-            'upgrade_perk': upgrade_perk
+            "upgrade_date": upgrade_date,
+            "upgrade_perk": upgrade_perk,
         }
         return perks
 
     def upgrade(self, perk, upgrade_type):
         """Craft item"""
         perk_keys = {
-            'strength': 1,
-            'education': 2,
-            'endurance': 3,
+            "strength": 1,
+            "education": 2,
+            "endurance": 3,
         }
         if isinstance(perk, str) and perk in perk_keys:
             perk_keys = perk_keys[perk]
 
         upgrade_type_keys = {
-            'money': 1,
-            'gold': 2,
+            "money": 1,
+            "gold": 2,
         }
-        if isinstance(upgrade_type, str) and upgrade_type in upgrade_type_keys:
+        if (
+            isinstance(upgrade_type, str)
+            and upgrade_type in upgrade_type_keys
+        ):
             upgrade_type = upgrade_type_keys[upgrade_type]
 
-        self.middleware.post(
-                'perks/up/{}/{}'.format(perk, upgrade_type)
-            )
+        self.middleware.post("perks/up/{}/{}".format(perk, upgrade_type))
         return True

src/rival_regions_wrapper/wrapper/profile.py

@@ -10,34 +10,36 @@ from rival_regions_wrapper.wrapper.abstract_wrapper import AbstractWrapper
 
 class Profile(AbstractWrapper):
     """Wrapper class for profile"""
+
     def __init__(self, middleware, profile_id):
         AbstractWrapper.__init__(self, middleware)
         self.profile_id = profile_id
 
     def info(self):
         """Get profile"""
-        path = 'slide/profile/{}'.format(self.profile_id)
+        path = "slide/profile/{}".format(self.profile_id)
         response = self.middleware.get(path)
-        soup = BeautifulSoup(response, 'html.parser')
-        level = soup.select_one('div.oil:nth-child(2) > div:nth-child(2)').text
-        perks = soup.select('table tr:nth-child(2) span')
+        soup = BeautifulSoup(response, "html.parser")
+        level = soup.select_one(
+            "div.oil:nth-child(2) > div:nth-child(2)"
+        ).text
+        perks = soup.select("table tr:nth-child(2) span")
         profile = {
-            'profile_id': self.profile_id,
-            'name': re.sub(r'.*:\s', '', soup.find('h1').text),
-            'level': int(re.sub(r'^Level\:\s|\s\(.*\)$', '', level)),
-            'level_percentage': int(
-                re.sub(r'^Level\:\s(\d+)\s\(|\s\%\)$', '', level)
+            "profile_id": self.profile_id,
+            "name": re.sub(r".*:\s", "", soup.find("h1").text),
+            "level": int(re.sub(r"^Level\:\s|\s\(.*\)$", "", level)),
+            "level_percentage": int(
+                re.sub(r"^Level\:\s(\d+)\s\(|\s\%\)$", "", level)
             ),
-            'strenght': int(perks[0].text),
-            'education': int(perks[1].text),
-            'endurance': int(perks[2].text),
+            "strenght": int(perks[0].text),
+            "education": int(perks[1].text),
+            "endurance": int(perks[2].text),
         }
         return profile
 
     def message(self, message):
         """send personal message"""
-        LOGGER.info('"%s": PM: user id %s',
-                self.middleware.username,
-                self.profile_id
-            )
+        LOGGER.info(
+            '"%s": PM: user id %s', self.middleware.username, self.profile_id
+        )
         api.profile_message(self.middleware, self.profile_id, message)

src/rival_regions_wrapper/wrapper/resource_state.py

@@ -9,33 +9,33 @@ from rival_regions_wrapper.wrapper.abstract_wrapper import AbstractWrapper
 
 class ResourceState(AbstractWrapper):
     """Wrapper class for resource state"""
+
     def __init__(self, middleware, state_id):
         AbstractWrapper.__init__(self, middleware)
         self.state_id = state_id
 
     def info(self, resource):
         """Get resource state"""
-        keys = {
-            3: 'oil',
-            4: 'ore',
-            11: 'uranium',
-            15: 'diamonds'
-        }
+        keys = {3: "oil", 4: "ore", 11: "uranium", 15: "diamonds"}
         if isinstance(resource, int) and resource in keys:
             resource = keys[resource]
-        path = 'listed/stateresources/{}/{}'.format(self.state_id, resource)
+        path = "listed/stateresources/{}/{}".format(self.state_id, resource)
         response = self.middleware.get(path)
-        soup = BeautifulSoup(response, 'html.parser')
-        regions_tree = soup.find_all(class_='list_link')
+        soup = BeautifulSoup(response, "html.parser")
+        regions_tree = soup.find_all(class_="list_link")
         regions = []
         for region_tree in regions_tree:
-            columns = region_tree.find_all('td')
-            regions.append({
-                'region_id': int(region_tree['user']),
-                'region_name': re.sub('Factories: .*$', '', columns[1].text),
-                'explored': float(columns[2].string),
-                'maximum': int(float(columns[3].string)),
-                'deep_exploration': int(columns[4].string),
-                'limit_left': int(columns[5].string),
-            })
+            columns = region_tree.find_all("td")
+            regions.append(
+                {
+                    "region_id": int(region_tree["user"]),
+                    "region_name": re.sub(
+                        "Factories: .*$", "", columns[1].text
+                    ),
+                    "explored": float(columns[2].string),
+                    "maximum": int(float(columns[3].string)),
+                    "deep_exploration": int(columns[4].string),
+                    "limit_left": int(columns[5].string),
+                }
+            )
         return regions

src/rival_regions_wrapper/wrapper/storage.py

@@ -9,18 +9,19 @@ from rival_regions_wrapper.wrapper.abstract_wrapper import AbstractWrapper
 
 class Storage(AbstractWrapper):
     """Wrapper class for storage"""
+
     def info(self):
         """storage info"""
-        path = 'storage'
+        path = "storage"
         response = self.middleware.get(path)
-        soup = BeautifulSoup(response, 'html.parser')
+        soup = BeautifulSoup(response, "html.parser")
         storage = {}
         for key, item_id in util.ITEM_KEYS.items():
             storage[key] = int(
-                soup.find('span', {'urlbar': item_id}).text.replace('.', '')
+                soup.find("span", {"urlbar": item_id}).text.replace(".", "")
             )
-            storage['{}_max'.format(key)] = int(
-                soup.find('span', {'urlbar': item_id})['maxstore']
+            storage["{}_max".format(key)] = int(
+                soup.find("span", {"urlbar": item_id})["maxstore"]
             )
 
         return storage

src/rival_regions_wrapper/wrapper/war.py

@@ -12,129 +12,134 @@ from rival_regions_wrapper.wrapper.abstract_wrapper import AbstractWrapper
 
 class War(AbstractWrapper):
     """Wrapper class for war"""
+
     def page(self):
         """Get training war"""
-        path = 'war'
+        path = "war"
         response = self.middleware.get(path)
-        soup = BeautifulSoup(response, 'html.parser')
-        pattern = re.compile(r'war\/details\/\d+')
-        script = soup.find('script', text=pattern)
+        soup = BeautifulSoup(response, "html.parser")
+        pattern = re.compile(r"war\/details\/\d+")
+        script = soup.find("script", text=pattern)
         war_url = pattern.search(str(script))
         if war_url:
-            training_war = int(war_url.group(0).replace('war/details/', ''))
+            training_war = int(war_url.group(0).replace("war/details/", ""))
         else:
             training_war = None
-        page = {
-            'training_war': training_war
-        }
+        page = {"training_war": training_war}
         return page
 
     def info(self, war_id):
         """Get war info"""
-        path = 'war/details/{}'.format(war_id)
+        path = "war/details/{}".format(war_id)
         response = self.middleware.get(path)
-        soup = BeautifulSoup(response, 'html.parser')
+        soup = BeautifulSoup(response, "html.parser")
         war_info = {
-            'war_id': war_id,
-            'damage': int(
-                soup.select_one('.war_w_target_o').text.replace('.', '')
+            "war_id": war_id,
+            "damage": int(
+                soup.select_one(".war_w_target_o").text.replace(".", "")
+            ),
+            "attack_hourly_available": bool(
+                soup.select_one(".hide_once_war")
             ),
-            'attack_hourly_available': bool(soup.select_one('.hide_once_war')),
         }
-        heading = soup.find('h1')
-        energ_drinks = re.search(r'\d+$', heading.select_one('.small').text)
+        heading = soup.find("h1")
+        energ_drinks = re.search(r"\d+$", heading.select_one(".small").text)
         if energ_drinks:
-            war_info['energ_drinks'] = int(energ_drinks.group(0))
+            war_info["energ_drinks"] = int(energ_drinks.group(0))
 
-        war_info['type'] = re.sub(r'(,|▶).*', '', heading.text).strip().lower()
-        war_type = soup.select_one('.no_pointer')
-        if war_type and war_type.text == 'Revolution powers':
-            war_info['type'] = 'revolution'
+        war_info["type"] = (
+            re.sub(r"(,|▶).*", "", heading.text).strip().lower()
+        )
+        war_type = soup.select_one(".no_pointer")
+        if war_type and war_type.text == "Revolution powers":
+            war_info["type"] = "revolution"
 
-        max_hero = heading.select_one('.max_hero')
+        max_hero = heading.select_one(".max_hero")
         if max_hero is not None:
-            war_info['max_hero_name'] = max_hero.text
-            war_info['max_hero_id'] = \
-                max_hero['action'].replace('slide/profile/', '')
+            war_info["max_hero_name"] = max_hero.text
+            war_info["max_hero_id"] = max_hero["action"].replace(
+                "slide/profile/", ""
+            )
 
-        max_hero_damage_str = ''.join(heading.find_all(
-                text=True, recursive=False
-            )).strip()
-        max_hero_damage = re.search(r'(\d|\.)+', max_hero_damage_str)
+        max_hero_damage_str = "".join(
+            heading.find_all(text=True, recursive=False)
+        ).strip()
+        max_hero_damage = re.search(r"(\d|\.)+", max_hero_damage_str)
         if max_hero_damage:
-            war_info['max_hero_damage'] = \
-                int(max_hero_damage.group(0).replace('.', ''))
+            war_info["max_hero_damage"] = int(
+                max_hero_damage.group(0).replace(".", "")
+            )
 
-        script = soup.find('script', text=re.compile('.war_det_cou'))
-        search_result = re.search(r'\'\d+\'', str(script))
+        script = soup.find("script", text=re.compile(".war_det_cou"))
+        search_result = re.search(r"\'\d+\'", str(script))
         if search_result:
-            seconds = int(search_result.group(0).replace('\'', ''))
-            war_info['time_left'] = timedelta(seconds=seconds)
-            war_info['finish_date'] = datetime.utcnow() + war_info['time_left']
+            seconds = int(search_result.group(0).replace("'", ""))
+            war_info["time_left"] = timedelta(seconds=seconds)
+            war_info["finish_date"] = (
+                datetime.utcnow() + war_info["time_left"]
+            )
         else:
-            war_info['time_left'] = None
+            war_info["time_left"] = None
             results = re.search(
-                    r'(?<=: ).*',
-                    soup.select_one('.slide_title .small').text
-                )
+                r"(?<=: ).*", soup.select_one(".slide_title .small").text
+            )
             if results:
-                war_info['finish_date'] = \
-                    util.parse_date(results.group(0))
+                war_info["finish_date"] = util.parse_date(results.group(0))
 
-        war_info['war_units'] = {}
-        for war_unit in soup.select('.war_w_unit_div'):
-            war_info['war_units'][war_unit['url']] = war_unit.text
+        war_info["war_units"] = {}
+        for war_unit in soup.select(".war_w_unit_div"):
+            war_info["war_units"][war_unit["url"]] = war_unit.text
 
-        attack_side = soup.select('#war_w_ata_s .hov2')
+        attack_side = soup.select("#war_w_ata_s .hov2")
         if len(attack_side) >= 3:
-            war_info['attack'] = {
-                'state_id': int(attack_side[0]['action'].replace(
-                    'map/state_details/', '')
+            war_info["attack"] = {
+                "state_id": int(
+                    attack_side[0]["action"].replace("map/state_details/", "")
                 ),
-                'state_name': unicodedata.normalize(
-                    'NFKD', attack_side[0].text
+                "state_name": unicodedata.normalize(
+                    "NFKD", attack_side[0].text
                 ),
-                'region_id': int(attack_side[1]['action'].replace(
-                    'map/details/', ''
-                )),
-                'region_name': unicodedata.normalize(
-                    'NFKD', attack_side[1].text
+                "region_id": int(
+                    attack_side[1]["action"].replace("map/details/", "")
                 ),
-                'damage': int(soup.select_one('.war_w_target_a').text.replace(
-                    '.', '')
+                "region_name": unicodedata.normalize(
+                    "NFKD", attack_side[1].text
+                ),
+                "damage": int(
+                    soup.select_one(".war_w_target_a").text.replace(".", "")
                 ),
             }
         else:
-            war_info['attack'] = {
-                'damage': int(soup.select_one('.war_w_target_a').text.replace(
-                    '.', '')
+            war_info["attack"] = {
+                "damage": int(
+                    soup.select_one(".war_w_target_a").text.replace(".", "")
                 ),
             }
 
-        defend_side = soup.select('#war_w_def_s .hov2')
+        defend_side = soup.select("#war_w_def_s .hov2")
         if len(defend_side) >= 3:
-            war_info['defend'] = {
-                'state_id': int(defend_side[0]['action'].replace(
-                    'map/state_details/', '')
+            war_info["defend"] = {
+                "state_id": int(
+                    defend_side[0]["action"].replace("map/state_details/", "")
+                ),
+                "state_name": unicodedata.normalize(
+                    "NFKD", defend_side[0].text
                 ),
-                'state_name': unicodedata.normalize(
-                    'NFKD', defend_side[0].text
+                "region_id": int(
+                    defend_side[1]["action"].replace("map/details/", "")
                 ),
-                'region_id': int(defend_side[1]['action'].replace(
-                    'map/details/', '')
+                "region_name": unicodedata.normalize(
+                    "NFKD", defend_side[1].text
                 ),
-                'region_name': unicodedata.normalize(
-                    'NFKD', defend_side[1].text
+                "damage": int(
+                    soup.select_one(".war_w_target_d").text.replace(".", "")
                 ),
-                'damage': int(soup.select_one('.war_w_target_d').text.replace(
-                    '.', ''
-                )),
             }
         else:
-            war_info['defend'] = {
-                'damage': int(soup.select_one('.war_w_target_d').text.replace(
-                    '.', ''
-                )),
+            war_info["defend"] = {
+                "damage": int(
+                    soup.select_one(".war_w_target_d").text.replace(".", "")
+                ),
             }
 
         return war_info

src/rival_regions_wrapper/wrapper/work.py

@@ -8,75 +8,75 @@ from rival_regions_wrapper.wrapper.abstract_wrapper import AbstractWrapper
 
 
 RESOURCE_DICT = {
-    'oil': 'oil',
-    'ore': 'ore',
-    'yellow': 'gold',
-    'uranium': 'uranium',
-    'diamond': 'diamond'
+    "oil": "oil",
+    "ore": "ore",
+    "yellow": "gold",
+    "uranium": "uranium",
+    "diamond": "diamond",
 }
 
 
 class Work(AbstractWrapper):
     """Wrapper class for work"""
+
     def page(self):
         """Get work page"""
-        path = 'work'
+        path = "work"
         response = self.middleware.get(path)
-        soup = BeautifulSoup(response, 'html.parser')
+        soup = BeautifulSoup(response, "html.parser")
 
-        factory = soup.select_one('.work_item:nth-child(9)')
-        factory_slide = factory.select_one('.factory_slide')
+        factory = soup.select_one(".work_item:nth-child(9)")
+        factory_slide = factory.select_one(".factory_slide")
         factory_dict = {
-            'id': int(factory_slide['action'].replace('factory/index/', '')),
-            'name': factory_slide.text
+            "id": int(factory_slide["action"].replace("factory/index/", "")),
+            "name": factory_slide.text,
         }
-        factory_owner = factory.select_one('.factory_whose')
+        factory_owner = factory.select_one(".factory_whose")
         if factory_owner:
-            factory_dict['owner_name'] = factory_owner.text
-            factory_dict['owner_id'] = factory_owner['action'].replace(
-                    'slide/profile/', ''
-                )
+            factory_dict["owner_name"] = factory_owner.text
+            factory_dict["owner_id"] = factory_owner["action"].replace(
+                "slide/profile/", ""
+            )
 
         level_str = re.search(
-                r'level\s\d+', factory.select_one('.work_source_1').text
-            )
+            r"level\s\d+", factory.select_one(".work_source_1").text
+        )
         if level_str:
-            factory_dict['level'] = int(re.sub(
-                r'level\s', '', level_str.group(0)
-            ))
+            factory_dict["level"] = int(
+                re.sub(r"level\s", "", level_str.group(0))
+            )
 
         string_list = []
-        factory_button = soup.select_one(
-                    '.work_factory_button'
-                )
+        factory_button = soup.select_one(".work_factory_button")
         if factory_button:
             for string in factory_button.strings:
                 string_list.append(string.strip())
             try:
                 wage = string_list[2]
-                if '%' in wage:
-                    factory_dict['wage_type'] = 'procentage'
-                    factory_dict['wage'] = float(wage.replace(' %', ''))
+                if "%" in wage:
+                    factory_dict["wage_type"] = "procentage"
+                    factory_dict["wage"] = float(wage.replace(" %", ""))
             except IndexError:
                 pass
 
         work_page = {
-            'factory': factory_dict,
-            'work_exp': {},
-            'resources_left': {},
+            "factory": factory_dict,
+            "work_exp": {},
+            "resources_left": {},
         }
 
-        for resource_left in soup.select('span.imp.tip'):
-            classses = resource_left.get('class')
+        for resource_left in soup.select("span.imp.tip"):
+            classses = resource_left.get("class")
             for class_name, resource_name in RESOURCE_DICT.items():
                 if class_name in classses:
-                    work_page['resources_left'][resource_name] = \
-                        float(resource_left.text)
+                    work_page["resources_left"][resource_name] = float(
+                        resource_left.text
+                    )
                     break
 
-        for work_exp in soup.select('.work_exp'):
-            work_exp_amount = int(re.sub(
-                    r'exp: | Pt\.', '', work_exp.text.strip()
-                ))
-            work_page['work_exp'][work_exp['url']] = work_exp_amount
+        for work_exp in soup.select(".work_exp"):
+            work_exp_amount = int(
+                re.sub(r"exp: | Pt\.", "", work_exp.text.strip())
+            )
+            work_page["work_exp"][work_exp["url"]] = work_exp_amount
         return work_page