Run black and flake8

Author: aaltat

src/SeleniumLibrary/__init__.pyi

@@ -13,7 +13,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from typing import Optional, Union
+from typing import Union
 
 from selenium.common.exceptions import TimeoutException, WebDriverException
 from selenium.webdriver.support import expected_conditions as EC
@@ -30,7 +30,9 @@ class AlertKeywords(LibraryComponent):
     _next_alert_action = ACCEPT
 
     @keyword
-    def input_text_into_alert(self, text: str, action: str = ACCEPT, timeout: Union[float, str, None] = None):
+    def input_text_into_alert(
+        self, text: str, action: str = ACCEPT, timeout: Union[float, str, None] = None
+    ):
         """Types the given ``text`` into an input field in an alert.
 
         The alert is accepted by default, but that behavior can be controlled
@@ -46,7 +48,12 @@ def input_text_into_alert(self, text: str, action: str = ACCEPT, timeout: Union[
         self._handle_alert(alert, action)
 
     @keyword
-    def alert_should_be_present(self, text: str = "", action: str = ACCEPT, timeout: Union[float, str, None] = None):
+    def alert_should_be_present(
+        self,
+        text: str = "",
+        action: str = ACCEPT,
+        timeout: Union[float, str, None] = None,
+    ):
         """Verifies that an alert is present and by default, accepts it.
 
         Fails if no alert is present. If ``text`` is a non-empty string,
@@ -68,7 +75,9 @@ def alert_should_be_present(self, text: str = "", action: str = ACCEPT, timeout:
             )
 
     @keyword
-    def alert_should_not_be_present(self, action: str = ACCEPT, timeout:  Union[float, str, None] = 0):
+    def alert_should_not_be_present(
+        self, action: str = ACCEPT, timeout: Union[float, str, None] = 0
+    ):
         """Verifies that no alert is present.
 
         If the alert actually exists, the ``action`` argument determines
@@ -91,7 +100,9 @@ def alert_should_not_be_present(self, action: str = ACCEPT, timeout:  Union[floa
         raise AssertionError(f"Alert with message '{text}' present.")
 
     @keyword
-    def handle_alert(self, action: str = ACCEPT, timeout:  Union[float, str, None] = None):
+    def handle_alert(
+        self, action: str = ACCEPT, timeout: Union[float, str, None] = None
+    ):
         """Handles the current alert and returns its message.
 
         By default, the alert is accepted, but this can be controlled

src/SeleniumLibrary/keywords/alert.py

@@ -342,7 +342,9 @@ def _make_new_browser(
         return index
 
     @keyword
-    def create_webdriver(self, driver_name: str, alias: Optional[str] = None, kwargs={}, **init_kwargs) -> str:
+    def create_webdriver(
+        self, driver_name: str, alias: Optional[str] = None, kwargs={}, **init_kwargs
+    ) -> str:
         """Creates an instance of Selenium WebDriver.
 
         Like `Open Browser`, but allows passing arguments to the created

src/SeleniumLibrary/keywords/browsermanagement.py

@@ -142,7 +142,15 @@ def get_cookie(self, name: str) -> CookieInformation:
         return CookieInformation(**cookie)
 
     @keyword
-    def add_cookie(self, name: str, value: str, path: Optional[str] = None, domain: Optional[str] = None, secure: Optional[str] = None, expiry: Optional[str] = None):
+    def add_cookie(
+        self,
+        name: str,
+        value: str,
+        path: Optional[str] = None,
+        domain: Optional[str] = None,
+        secure: Optional[str] = None,
+        expiry: Optional[str] = None,
+    ):
         """Adds a cookie to your current session.
 
         ``name`` and ``value`` are required, ``path``, ``domain``, ``secure``

src/SeleniumLibrary/keywords/cookie.py

@@ -14,7 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from collections import namedtuple
-from typing import List, Optional
+from typing import List, Optional, Tuple
 
 from robot.utils import plural_or_not
 from selenium.webdriver.common.action_chains import ActionChains
@@ -51,7 +51,11 @@ def get_webelements(self, locator: str) -> List[WebElement]:
 
     @keyword
     def element_should_contain(
-        self, locator: str, expected: str, message: Optional[str] = None, ignore_case: bool = False
+        self,
+        locator: str,
+        expected: str,
+        message: Optional[str] = None,
+        ignore_case: bool = False,
     ):
         """Verifies that element ``locator`` contains text ``expected``.
 
@@ -85,7 +89,11 @@ def element_should_contain(
 
     @keyword
     def element_should_not_contain(
-        self, locator: str, expected: str, message: Optional[str] = None, ignore_case: bool = False
+        self,
+        locator: str,
+        expected: str,
+        message: Optional[str] = None,
+        ignore_case: bool = False,
     ):
         """Verifies that element ``locator`` does not contain text ``expected``.
 
@@ -133,7 +141,11 @@ def page_should_contain(self, text: str, loglevel: str = "TRACE"):
 
     @keyword
     def page_should_contain_element(
-        self, locator: str, message: Optional[str] = None, loglevel: Optional[str] = "TRACE", limit: Optional[int] = None
+        self,
+        locator: str,
+        message: Optional[str] = None,
+        loglevel: Optional[str] = "TRACE",
+        limit: Optional[int] = None,
     ):
         """Verifies that element ``locator`` is found on the current page.
 
@@ -189,7 +201,9 @@ def page_should_not_contain(self, text: str, loglevel: str = "TRACE"):
         self.info(f"Current page does not contain text '{text}'.")
 
     @keyword
-    def page_should_not_contain_element(self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"):
+    def page_should_not_contain_element(
+        self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"
+    ):
         """Verifies that element ``locator`` is not found on the current page.
 
         See the `Locating elements` section for details about the locator
@@ -284,7 +298,9 @@ def element_should_be_visible(self, locator: str, message: Optional[str] = None)
         self.info(f"Element '{locator}' is displayed.")
 
     @keyword
-    def element_should_not_be_visible(self, locator: str, message: Optional[str] = None):
+    def element_should_not_be_visible(
+        self, locator: str, message: Optional[str] = None
+    ):
         """Verifies that the element identified by ``locator`` is NOT visible.
 
         Passes if the element does not exists. See `Element Should Be Visible`
@@ -302,7 +318,11 @@ def element_should_not_be_visible(self, locator: str, message: Optional[str] = N
 
     @keyword
     def element_text_should_be(
-        self, locator: str, expected: str, message: Optional[str] = None, ignore_case: bool = False
+        self,
+        locator: str,
+        expected: str,
+        message: Optional[str] = None,
+        ignore_case: bool = False,
     ):
         """Verifies that element ``locator`` contains exact the text ``expected``.
 
@@ -334,7 +354,11 @@ def element_text_should_be(
 
     @keyword
     def element_text_should_not_be(
-        self, locator: str, not_expected: str, message: Optional[str] = None, ignore_case: bool = False
+        self,
+        locator: str,
+        not_expected: str,
+        message: Optional[str] = None,
+        ignore_case: bool = False,
     ):
         """Verifies that element ``locator`` does not contain exact the text ``not_expected``.
 
@@ -419,7 +443,7 @@ def get_horizontal_position(self, locator: str) -> int:
         return self.find_element(locator).location["x"]
 
     @keyword
-    def get_element_size(self, locator: str) -> int:
+    def get_element_size(self, locator: str) -> Tuple[int, int]:
         """Returns width and height of the element identified by ``locator``.
 
         See the `Locating elements` section for details about the locator
@@ -571,7 +595,9 @@ def click_link(self, locator: str, modifier: Optional[str] = False):
             self._click_with_modifier(locator, ["link", "link"], modifier)
 
     @keyword
-    def click_element(self, locator: str, modifier: Optional[str] = False, action_chain: bool = False):
+    def click_element(
+        self, locator: str, modifier: Optional[str] = False, action_chain: bool = False
+    ):
         """Click the element identified by ``locator``.
 
         See the `Locating elements` section for details about the locator
@@ -953,7 +979,9 @@ def mouse_down_on_link(self, locator: str):
         action.click_and_hold(element).perform()
 
     @keyword
-    def page_should_contain_link(self, locator: str, message: Optional[str] = None, loglevel: str="TRACE"):
+    def page_should_contain_link(
+        self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"
+    ):
         """Verifies link identified by ``locator`` is found from current page.
 
         See the `Locating elements` section for details about the locator
@@ -966,7 +994,9 @@ def page_should_contain_link(self, locator: str, message: Optional[str] = None,
         self.assert_page_contains(locator, "link", message, loglevel)
 
     @keyword
-    def page_should_not_contain_link(self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"):
+    def page_should_not_contain_link(
+        self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"
+    ):
         """Verifies link identified by ``locator`` is not found from current page.
 
         See the `Locating elements` section for details about the locator
@@ -991,7 +1021,9 @@ def mouse_down_on_image(self, locator: str):
         action.click_and_hold(element).perform()
 
     @keyword
-    def page_should_contain_image(self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"):
+    def page_should_contain_image(
+        self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"
+    ):
         """Verifies image identified by ``locator`` is found from current page.
 
         See the `Locating elements` section for details about the locator
@@ -1004,7 +1036,9 @@ def page_should_contain_image(self, locator: str, message: Optional[str] = None,
         self.assert_page_contains(locator, "image", message, loglevel)
 
     @keyword
-    def page_should_not_contain_image(self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"):
+    def page_should_not_contain_image(
+        self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"
+    ):
         """Verifies image identified by ``locator`` is not found from current page.
 
         See the `Locating elements` section for details about the locator
@@ -1033,7 +1067,9 @@ def get_element_count(self, locator: str) -> int:
         return len(self.find_elements(locator))
 
     @keyword
-    def add_location_strategy(self, strategy_name: str, strategy_keyword: str, persist: bool = False):
+    def add_location_strategy(
+        self, strategy_name: str, strategy_keyword: str, persist: bool = False
+    ):
         """Adds a custom location strategy.
 
         See `Custom locators` for information on how to create and use

src/SeleniumLibrary/keywords/element.py

@@ -67,7 +67,9 @@ def checkbox_should_not_be_selected(self, locator: str):
             raise AssertionError(f"Checkbox '{locator}' should not have been selected.")
 
     @keyword
-    def page_should_contain_checkbox(self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"):
+    def page_should_contain_checkbox(
+        self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"
+    ):
         """Verifies checkbox ``locator`` is found from the current page.
 
         See `Page Should Contain Element` for an explanation about ``message``
@@ -79,7 +81,9 @@ def page_should_contain_checkbox(self, locator: str, message: Optional[str] = No
         self.assert_page_contains(locator, "checkbox", message, loglevel)
 
     @keyword
-    def page_should_not_contain_checkbox(self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"):
+    def page_should_not_contain_checkbox(
+        self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"
+    ):
         """Verifies checkbox ``locator`` is not found from the current page.
 
         See `Page Should Contain Element` for an explanation about ``message``
@@ -119,7 +123,9 @@ def unselect_checkbox(self, locator: str):
             element.click()
 
     @keyword
-    def page_should_contain_radio_button(self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"):
+    def page_should_contain_radio_button(
+        self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"
+    ):
         """Verifies radio button ``locator`` is found from current page.
 
         See `Page Should Contain Element` for an explanation about ``message``
@@ -275,7 +281,9 @@ def input_text(self, locator: str, text: str, clear: bool = True):
         self._input_text_into_text_field(locator, text, clear)
 
     @keyword
-    def page_should_contain_textfield(self, locator: str, message: Optional[str] = None, loglevel: str="TRACE"):
+    def page_should_contain_textfield(
+        self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"
+    ):
         """Verifies text field ``locator`` is found from current page.
 
         See `Page Should Contain Element` for an explanation about ``message``
@@ -301,7 +309,9 @@ def page_should_not_contain_textfield(
         self.assert_page_not_contains(locator, "text field", message, loglevel)
 
     @keyword
-    def textfield_should_contain(self, locator: str, expected: str, message: Optional[str] = None):
+    def textfield_should_contain(
+        self, locator: str, expected: str, message: Optional[str] = None
+    ):
         """Verifies text field ``locator`` contains text ``expected``.
 
         ``message`` can be used to override the default error message.
@@ -320,7 +330,9 @@ def textfield_should_contain(self, locator: str, expected: str, message: Optiona
         self.info(f"Text field '{locator}' contains text '{expected}'.")
 
     @keyword
-    def textfield_value_should_be(self, locator: str, expected: str, message: Optional[str] = None):
+    def textfield_value_should_be(
+        self, locator: str, expected: str, message: Optional[str] = None
+    ):
         """Verifies text field ``locator`` has exactly text ``expected``.
 
         ``message`` can be used to override default error message.
@@ -339,7 +351,9 @@ def textfield_value_should_be(self, locator: str, expected: str, message: Option
         self.info(f"Content of text field '{locator}' is '{expected}'.")
 
     @keyword
-    def textarea_should_contain(self, locator: str, expected: str, message: Optional[str] = None):
+    def textarea_should_contain(
+        self, locator: str, expected: str, message: Optional[str] = None
+    ):
         """Verifies text area ``locator`` contains text ``expected``.
 
         ``message`` can be used to override default error message.
@@ -358,7 +372,9 @@ def textarea_should_contain(self, locator: str, expected: str, message: Optional
         self.info(f"Text area '{locator}' contains text '{expected}'.")
 
     @keyword
-    def textarea_value_should_be(self, locator: str, expected: str, message: Optional[str] = None):
+    def textarea_value_should_be(
+        self, locator: str, expected: str, message: Optional[str] = None
+    ):
         """Verifies text area ``locator`` has exactly text ``expected``.
 
         ``message`` can be used to override default error message.
@@ -377,7 +393,9 @@ def textarea_value_should_be(self, locator: str, expected: str, message: Optiona
         self.info(f"Content of text area '{locator}' is '{expected}'.")
 
     @keyword
-    def page_should_contain_button(self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"):
+    def page_should_contain_button(
+        self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"
+    ):
         """Verifies button ``locator`` is found from current page.
 
         See `Page Should Contain Element` for an explanation about ``message``
@@ -393,7 +411,9 @@ def page_should_contain_button(self, locator: str, message: Optional[str] = None
             self.assert_page_contains(locator, "button", message, loglevel)
 
     @keyword
-    def page_should_not_contain_button(self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"):
+    def page_should_not_contain_button(
+        self, locator: str, message: Optional[str] = None, loglevel: str = "TRACE"
+    ):
         """Verifies button ``locator`` is not found from current page.
 
         See `Page Should Contain Element` for an explanation about ``message``

src/SeleniumLibrary/keywords/formelement.py

@@ -126,14 +126,14 @@ def _separate_code_and_args(self, code):
         self._check_marker_error(code)
         index = self._get_marker_index(code)
         if self.arg_marker not in code:
-            return code[index.js + 1 :], []
+            return code[index.js + 1:], []
         if self.js_marker not in code:
-            return code[0 : index.arg], code[index.arg + 1 :]
+            return code[0: index.arg], code[index.arg + 1:]
         else:
             if index.js == 0:
-                return code[index.js + 1 : index.arg], code[index.arg + 1 :]
+                return code[index.js + 1: index.arg], code[index.arg + 1:]
             else:
-                return code[index.js + 1 :], code[index.arg + 1 : index.js]
+                return code[index.js + 1:], code[index.arg + 1: index.js]
 
     def _check_marker_error(self, code):
         if not code:

src/SeleniumLibrary/keywords/javascript.py

@@ -125,7 +125,9 @@ def _capture_page_screen_to_log(self):
         return EMBED
 
     @keyword
-    def capture_element_screenshot(self, locator: str, filename: str = DEFAULT_FILENAME_ELEMENT) -> str:
+    def capture_element_screenshot(
+        self, locator: str, filename: str = DEFAULT_FILENAME_ELEMENT
+    ) -> str:
         """Captures a screenshot from the element identified by ``locator`` and embeds it into log file.
 
         See `Capture Page Screenshot` for details about ``filename`` argument.