ruff format fixes

Author: yuriverweij

atest/acceptance/1-plugin/OpenBrowserExample.py

@@ -121,7 +121,12 @@ def create_driver(
         )
 
     def create_seleniumwire(
-        self, desired_capabilities, remote_url, options=None, service_log_path=None, service=None,
+        self,
+        desired_capabilities,
+        remote_url,
+        options=None,
+        service_log_path=None,
+        service=None,
     ):
         logger.info(self.extra_dictionary)
         return webdriver.Chrome()

atest/resources/testlibs/get_driver_path.py

@@ -18,6 +18,7 @@ def _import_options(self, browser):
         return options.Options
 
 """
+
 from selenium import webdriver
 from selenium.webdriver.common import driver_finder
 import importlib
@@ -30,12 +31,12 @@ def get_driver_path(browser):
     options = importlib.import_module(f"selenium.webdriver.{browser}.options")
 
     args = inspect.signature(driver_finder.DriverFinder.__init__).parameters.keys()
-    if ('service' in args) and ('options' in args):
+    if ("service" in args) and ("options" in args):
         # Selenium V4.20.0 or greater
         finder = driver_finder.DriverFinder(service.Service(), options.Options())
         return finder.get_driver_path()
     else:
         # Selenium v4.19.0 and prior
         finder = driver_finder.DriverFinder()
-        func = getattr(finder, 'get_path')
+        func = getattr(finder, "get_path")
         return finder.get_path(service.Service(), options.Options())

atest/run.py

@@ -181,7 +181,7 @@ def _grid_status(status=False, role="hub"):
 
 
 @contextmanager
-def http_server(interpreter, port:int):
+def http_server(interpreter, port: int):
     serverlog = open(os.path.join(RESULTS_DIR, "serverlog.txt"), "w")
     interpreter = "python" if not interpreter else interpreter
     process = subprocess.Popen(
@@ -215,7 +215,12 @@ def execute_tests(interpreter, browser, rf_options, grid, event_firing, port):
     options.extend([opt.format(browser=browser) for opt in ROBOT_OPTIONS])
     if rf_options:
         options += rf_options
-    options += ["--exclude", f"known issue {browser.replace('headless', '')}", "--exclude", "triage"]
+    options += [
+        "--exclude",
+        f"known issue {browser.replace('headless', '')}",
+        "--exclude",
+        "triage",
+    ]
     command = runner
     if grid:
         command += [
@@ -259,7 +264,7 @@ def process_output(browser):
         return exit.code
 
 
-def create_zip(browser = None):
+def create_zip(browser=None):
     if os.path.exists(ZIP_DIR):
         shutil.rmtree(ZIP_DIR)
     os.mkdir(ZIP_DIR)

src/SeleniumLibrary/keywords/alert.py

@@ -146,6 +146,10 @@ def _wait_alert(self, timeout=None):
         try:
             return wait.until(EC.alert_is_present())
         except TimeoutException as original_exception:
-            raise AssertionError(f"Alert not found in {secs_to_timestr(timeout)}.") from original_exception
+            raise AssertionError(
+                f"Alert not found in {secs_to_timestr(timeout)}."
+            ) from original_exception
         except WebDriverException as err:
-            raise AssertionError(f"An exception occurred waiting for alert: {err}") from err
+            raise AssertionError(
+                f"An exception occurred waiting for alert: {err}"
+            ) from err

src/SeleniumLibrary/keywords/browsermanagement.py

@@ -217,11 +217,17 @@ def open_browser(
                 self.go_to(url)
             return index
         if desired_capabilities:
-            self.warn("desired_capabilities has been deprecated and removed. Please use options to configure browsers as per documentation.")
+            self.warn(
+                "desired_capabilities has been deprecated and removed. Please use options to configure browsers as per documentation."
+            )
         if service_log_path:
-            self.warn("service_log_path is being deprecated. Please use service to configure log_output or equivalent service attribute.")
+            self.warn(
+                "service_log_path is being deprecated. Please use service to configure log_output or equivalent service attribute."
+            )
         if executable_path:
-            self.warn("executable_path is being deprecated. Please use service to configure the driver's executable_path as per documentation.")
+            self.warn(
+                "executable_path is being deprecated. Please use service to configure the driver's executable_path as per documentation."
+            )
         return self._make_new_browser(
             url,
             browser,
@@ -280,7 +286,11 @@ def _make_new_browser(
 
     @keyword
     def create_webdriver(
-        self, driver_name: str, alias: str | None = None, kwargs: dict | None = None, **init_kwargs
+        self,
+        driver_name: str,
+        alias: str | None = None,
+        kwargs: dict | None = None,
+        **init_kwargs,
     ) -> str:
         """Creates an instance of Selenium WebDriver.
 
@@ -320,7 +330,9 @@ def create_webdriver(
         try:
             creation_func = getattr(webdriver, driver_name)
         except AttributeError as original_exception:
-            raise RuntimeError(f"'{driver_name}' is not a valid WebDriver name.") from original_exception
+            raise RuntimeError(
+                f"'{driver_name}' is not a valid WebDriver name."
+            ) from original_exception
         self.info(f"Creating an instance of the {driver_name} WebDriver.")
         driver = creation_func(**init_kwargs)
         self.debug(
@@ -659,8 +671,7 @@ def set_action_chain_delay(self, value: timedelta) -> str:
 
     @keyword
     def get_action_chain_delay(self):
-        """Gets the currently stored value for chain_delay_value in timestr format.
-        """
+        """Gets the currently stored value for chain_delay_value in timestr format."""
         return timestr_to_secs(f"{self.ctx.action_chain_delay} milliseconds")
 
     @keyword

src/SeleniumLibrary/keywords/element.py

@@ -224,7 +224,7 @@ def page_should_not_contain_element(
         self.assert_page_not_contains(locator, message=message, loglevel=loglevel)
 
     @keyword
-    def assign_id_to_element(self, locator: Locator, id: str): # noqa: A002
+    def assign_id_to_element(self, locator: Locator, id: str):  # noqa: A002
         """Assigns a temporary ``id`` to the element specified by ``locator``.
 
         This is mainly useful if the locator is complicated and/or slow XPath
@@ -286,9 +286,7 @@ def element_should_be_focused(self, locator: Locator):
             raise AssertionError(f"Element '{locator}' does not have focus.")
 
     @keyword
-    def element_should_be_visible(
-        self, locator: Locator, message: str | None = None
-    ):
+    def element_should_be_visible(self, locator: Locator, message: str | None = None):
         """Verifies that the element identified by ``locator`` is visible.
 
         Herein, visible means that the element is logically visible, not
@@ -398,9 +396,7 @@ def element_text_should_not_be(
             raise AssertionError(message)
 
     @keyword
-    def get_element_attribute(
-        self, locator: Locator, attribute: str
-    ) -> str:
+    def get_element_attribute(self, locator: Locator, attribute: str) -> str:
         """Returns the value of ``attribute`` from the element ``locator``.
 
         See the `Locating elements` section for details about the locator
@@ -416,9 +412,7 @@ def get_element_attribute(
         return self.find_element(locator).get_attribute(attribute)
 
     @keyword
-    def get_dom_attribute(
-        self, locator: Locator, attribute: str
-    ) -> str:
+    def get_dom_attribute(self, locator: Locator, attribute: str) -> str:
         """Returns the value of ``attribute`` from the element ``locator``. `Get DOM Attribute` keyword
         only returns attributes declared within the element's HTML markup.  If the requested attribute
         is not there, the keyword returns ${None}.
@@ -434,7 +428,9 @@ def get_dom_attribute(
 
     @keyword
     def get_property(
-        self, locator: Locator, property: str  # noqa: A002
+        self,
+        locator: Locator,
+        property: str,  # noqa: A002
     ) -> str:
         """Returns the value of ``property`` from the element ``locator``.
 
@@ -581,9 +577,7 @@ def get_vertical_position(self, locator: Locator) -> int:
         return self.find_element(locator).location["y"]
 
     @keyword
-    def click_button(
-        self, locator: Locator, modifier: bool | str = False
-    ):
+    def click_button(self, locator: Locator, modifier: bool | str = False):
         """Clicks the button identified by ``locator``.
 
         See the `Locating elements` section for details about the locator
@@ -605,9 +599,7 @@ def click_button(
             self._click_with_modifier(locator, ["button", "input"], modifier)
 
     @keyword
-    def click_image(
-        self, locator: Locator, modifier: bool | str = False
-    ):
+    def click_image(self, locator: Locator, modifier: bool | str = False):
         """Clicks an image identified by ``locator``.
 
         See the `Locating elements` section for details about the locator
@@ -630,9 +622,7 @@ def click_image(
             self._click_with_modifier(locator, ["image", "input"], modifier)
 
     @keyword
-    def click_link(
-        self, locator: Locator, modifier: bool | str = False
-    ):
+    def click_link(self, locator: Locator, modifier: bool | str = False):
         """Clicks a link identified by ``locator``.
 
         See the `Locating elements` section for details about the locator
@@ -774,12 +764,12 @@ def scroll_element_into_view(self, locator: Locator):
         New in SeleniumLibrary 3.2.0
         """
         element = self.find_element(locator)
-        ActionChains(self.driver, duration=self.ctx.action_chain_delay).move_to_element(element).perform()
+        ActionChains(self.driver, duration=self.ctx.action_chain_delay).move_to_element(
+            element
+        ).perform()
 
     @keyword
-    def drag_and_drop(
-        self, locator: Locator, target: Locator
-    ):
+    def drag_and_drop(self, locator: Locator, target: Locator):
         """Drags the element identified by ``locator`` into the ``target`` element.
 
         The ``locator`` argument is the locator of the dragged element
@@ -795,9 +785,7 @@ def drag_and_drop(
         action.drag_and_drop(element, target).perform()
 
     @keyword
-    def drag_and_drop_by_offset(
-        self, locator: Locator, xoffset: int, yoffset: int
-    ):
+    def drag_and_drop_by_offset(self, locator: Locator, xoffset: int, yoffset: int):
         """Drags the element identified with ``locator`` by ``xoffset/yoffset``.
 
         See the `Locating elements` section for details about the locator
@@ -869,7 +857,9 @@ def mouse_up(self, locator: Locator):
         """
         self.info(f"Simulating Mouse Up on element '{locator}'.")
         element = self.find_element(locator)
-        ActionChains(self.driver, duration=self.ctx.action_chain_delay).release(element).perform()
+        ActionChains(self.driver, duration=self.ctx.action_chain_delay).release(
+            element
+        ).perform()
 
     @keyword
     def open_context_menu(self, locator: Locator):
@@ -988,7 +978,9 @@ def press_keys(self, locator: Locator | None = None, *keys: str):
         if not is_noney(locator):
             self.info(f"Sending key(s) {keys} to {locator} element.")
             element = self.find_element(locator)
-            ActionChains(self.driver, duration=self.ctx.action_chain_delay).click(element).perform()
+            ActionChains(self.driver, duration=self.ctx.action_chain_delay).click(
+                element
+            ).perform()
         else:
             self.info(f"Sending key(s) {keys} to page.")
             element = None
@@ -1228,7 +1220,9 @@ def parse_modifier(self, modifier):
             if hasattr(Keys, modifier):
                 keys.append(getattr(Keys, modifier))
             else:
-                raise ValueError(f"'{modifier}' modifier does not match to Selenium Keys")
+                raise ValueError(
+                    f"'{modifier}' modifier does not match to Selenium Keys"
+                )
         return keys
 
     def _parse_keys(self, *keys):
@@ -1271,18 +1265,20 @@ def _convert_special_keys(self, keys):
         for key in keys:
             resolved_key = self._parse_aliases(key)
             if self._selenium_keys_has_attr(resolved_key):
-                converted_keys.append(self.KeysRecord(getattr(Keys, resolved_key), resolved_key, True))
+                converted_keys.append(
+                    self.KeysRecord(getattr(Keys, resolved_key), resolved_key, True)
+                )
             else:
-                converted_keys.append(self.KeysRecord(resolved_key, resolved_key, False))
+                converted_keys.append(
+                    self.KeysRecord(resolved_key, resolved_key, False)
+                )
         return converted_keys
 
     def _selenium_keys_has_attr(self, key):
         return hasattr(Keys, key)
 
     @keyword("Get CSS Property Value")
-    def get_css_property_value(
-            self, locator: Locator, css_property: str
-    ) -> str:
+    def get_css_property_value(self, locator: Locator, css_property: str) -> str:
         """Returns the computed value of ``css_property`` from the element ``locator``.
 
         See the `Locating elements` section for details about the locator syntax.

src/SeleniumLibrary/keywords/expectedconditions.py

@@ -22,7 +22,9 @@
 
 class ExpectedConditionKeywords(LibraryComponent):
     @keyword
-    def wait_for_expected_condition(self, condition: string, *args, timeout: float | None=10):
+    def wait_for_expected_condition(
+        self, condition: string, *args, timeout: float | None = 10
+    ):
         """Waits until ``condition`` is true or ``timeout`` expires.
 
         The condition must be one of selenium's expected condition which
@@ -54,8 +56,13 @@ def wait_for_expected_condition(self, condition: string, *args, timeout: float |
         try:
             condition_func = getattr(EC, condition)
         except AttributeError as original_exception:
-            raise UnkownExpectedCondition(f"{condition} is an unknown expected condition") from original_exception
-        return wait.until(condition_func(*args), message=f"Expected Condition not met within set timeout of {timeout}s")
+            raise UnkownExpectedCondition(
+                f"{condition} is an unknown expected condition"
+            ) from original_exception
+        return wait.until(
+            condition_func(*args),
+            message=f"Expected Condition not met within set timeout of {timeout}s",
+        )
 
     def _parse_condition(self, condition: string):
-        return condition.replace(' ','_').lower()
+        return condition.replace(" ", "_").lower()

src/SeleniumLibrary/keywords/formelement.py

@@ -238,9 +238,7 @@ def choose_file(self, locator: Locator, file_path: str):
             self.ctx._running_keyword = None
 
     @keyword
-    def input_password(
-        self, locator: Locator, password: str, clear: bool = True
-    ):
+    def input_password(self, locator: Locator, password: str, clear: bool = True):
         """Types the given password into the text field identified by ``locator``.
 
         See the `Locating elements` section for details about the locator
@@ -268,9 +266,7 @@ def input_password(
         self._input_text_into_text_field(locator, password, clear, disable_log=True)
 
     @keyword
-    def input_text(
-        self, locator: Locator, text: str, clear: bool = True
-    ):
+    def input_text(self, locator: Locator, text: str, clear: bool = True):
         """Types the given ``text`` into the text field identified by ``locator``.
 
         When ``clear`` is true, the input element is cleared before
@@ -489,8 +485,7 @@ def _get_radio_button_with_value(self, group_name, value):
             return self.find_element(xpath)
         except ElementNotFound as original_exception:
             raise ElementNotFound(
-                f"No radio button with name '{group_name}' "
-                f"and value '{value}' found."
+                f"No radio button with name '{group_name}' and value '{value}' found."
             ) from original_exception
 
     def _get_value_from_radio_buttons(self, elements):

src/SeleniumLibrary/keywords/javascript.py

@@ -23,7 +23,6 @@
 
 
 class JavaScriptKeywords(LibraryComponent):
-
     js_marker = "JAVASCRIPT"
     arg_marker = "ARGUMENTS"
 

src/SeleniumLibrary/keywords/runonfailure.py

@@ -64,9 +64,7 @@ def resolve_keyword(name):
         if name is None:
             return None
         if (
-            (isinstance(name, str)
-            and name.upper() == "NOTHING")
-            or name.upper() == "NONE"
-        ):
+            isinstance(name, str) and name.upper() == "NOTHING"
+        ) or name.upper() == "NONE":
             return None
         return name