seleniumbase 4.41.3__py3-none-any.whl → 4.45.10__py3-none-any.whl

seleniumbase/core/detect_b_ver.py

@@ -40,6 +40,10 @@ class OSType(object):
 class ChromeType(object):
     GOOGLE = "google-chrome"
     MSEDGE = "edge"
+    OPERA = "opera"
+    BRAVE = "brave"
+    COMET = "comet"
+    ATLAS = "atlas"
 
 
 PATTERN = {
@@ -96,13 +100,27 @@ def linux_browser_apps_to_cmd(*apps):
     )
 
 
-def chrome_on_linux_path(chromium_ok=False):
+def chrome_on_linux_path(chromium_ok=False, browser_type=None):
+    if browser_type and browser_type != ChromeType.GOOGLE:
+        return ""
     if os_name() != OSType.LINUX:
         return ""
-    paths = ["/bin/google-chrome", "/bin/google-chrome-stable"]
+    paths = [
+        "/bin/google-chrome",
+        "/bin/google-chrome-stable",
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable"
+    ]
     for path in paths:
-        if os.path.exists(path) and os.access(path, os.X_OK):
-            return path
+        try:
+            if (
+                os.path.exists(path)
+                and os.access(path, os.R_OK)
+                and os.access(path, os.X_OK)
+            ):
+                return path
+        except Exception:
+            pass
     paths = os.environ["PATH"].split(os.pathsep)
     binaries = []
     binaries.append("google-chrome")
@@ -116,17 +134,38 @@ def chrome_on_linux_path(chromium_ok=False):
     for binary in binaries:
         for path in paths:
             full_path = os.path.join(path, binary)
-            if os.path.exists(full_path) and os.access(full_path, os.X_OK):
-                return full_path
+            try:
+                if (
+                    os.path.exists(full_path)
+                    and os.access(full_path, os.R_OK)
+                    and os.access(full_path, os.X_OK)
+                ):
+                    return full_path
+            except Exception:
+                pass
     if chromium_ok:
-        paths = ["/bin/chromium", "/bin/chromium-browser"]
+        paths = [
+            "/bin/chromium",
+            "/bin/chromium-browser",
+            "/usr/bin/chromium",
+            "/usr/bin/chromium-browser"
+        ]
         for path in paths:
-            if os.path.exists(path) and os.access(path, os.X_OK):
-                return path
+            try:
+                if (
+                    os.path.exists(path)
+                    and os.access(path, os.R_OK)
+                    and os.access(path, os.X_OK)
+                ):
+                    return path
+            except Exception:
+                pass
     return "/usr/bin/google-chrome"
 
 
-def edge_on_linux_path():
+def edge_on_linux_path(browser_type=None):
+    if browser_type and browser_type != ChromeType.MSEDGE:
+        return ""
     if os_name() != OSType.LINUX:
         return ""
     paths = os.environ["PATH"].split(os.pathsep)
@@ -143,7 +182,60 @@ def edge_on_linux_path():
     return "/usr/bin/microsoft-edge"
 
 
-def chrome_on_windows_path():
+def opera_on_linux_path(browser_type=None):
+    if browser_type and browser_type != ChromeType.OPERA:
+        return ""
+    if os_name() != OSType.LINUX:
+        return ""
+    paths = os.environ["PATH"].split(os.pathsep)
+    binaries = []
+    binaries.append("opera")
+    binaries.append("opera-stable")
+    for binary in binaries:
+        for path in paths:
+            full_path = os.path.join(path, binary)
+            if os.path.exists(full_path) and os.access(full_path, os.X_OK):
+                return full_path
+    return "/usr/bin/opera-stable"
+
+
+def brave_on_linux_path(browser_type=None):
+    if browser_type and browser_type != ChromeType.BRAVE:
+        return ""
+    if os_name() != OSType.LINUX:
+        return ""
+    paths = os.environ["PATH"].split(os.pathsep)
+    binaries = []
+    binaries.append("brave-browser")
+    binaries.append("brave")
+    binaries.append("brave-browser-stable")
+    for binary in binaries:
+        for path in paths:
+            full_path = os.path.join(path, binary)
+            if os.path.exists(full_path) and os.access(full_path, os.X_OK):
+                return full_path
+    return "/usr/bin/brave-browser"
+
+
+def comet_on_linux_path(browser_type=None):
+    if browser_type and browser_type != ChromeType.COMET:
+        return ""
+    if os_name() != OSType.LINUX:
+        return ""
+    return ""  # Comet Browser isn't supported on Linux yet
+
+
+def atlas_on_linux_path(browser_type=None):
+    if browser_type and browser_type != ChromeType.ATLAS:
+        return ""
+    if os_name() != OSType.LINUX:
+        return ""
+    return ""  # Atlas Browser isn't supported on Linux yet
+
+
+def chrome_on_windows_path(browser_type=None):
+    if browser_type and browser_type != ChromeType.GOOGLE:
+        return ""
     if os_name() != OSType.WIN:
         return ""
     candidates = []
@@ -171,7 +263,9 @@ def chrome_on_windows_path():
     return ""
 
 
-def edge_on_windows_path():
+def edge_on_windows_path(browser_type=None):
+    if browser_type and browser_type != ChromeType.MSEDGE:
+        return ""
     if os_name() != OSType.WIN:
         return ""
     candidates = []
@@ -199,6 +293,124 @@ def edge_on_windows_path():
     return ""
 
 
+def opera_on_windows_path(browser_type=None):
+    if browser_type and browser_type != ChromeType.OPERA:
+        return ""
+    if os_name() != OSType.WIN:
+        return ""
+    candidates = []
+    for item in map(
+        os.environ.get,
+        (
+            "PROGRAMFILES",
+            "PROGRAMFILES(X86)",
+            "LOCALAPPDATA",
+            "PROGRAMW6432",
+        ),
+    ):
+        for subitem in (
+            "Programs/Opera",
+            "Opera",
+            "Opera/Application",
+        ):
+            try:
+                candidates.append(os.sep.join((item, subitem, "opera.exe")))
+            except TypeError:
+                pass
+    for candidate in candidates:
+        if os.path.exists(candidate) and os.access(candidate, os.X_OK):
+            return os.path.normpath(candidate)
+    return ""
+
+
+def brave_on_windows_path(browser_type=None):
+    if browser_type and browser_type != ChromeType.BRAVE:
+        return ""
+    if os_name() != OSType.WIN:
+        return ""
+    candidates = []
+    for item in map(
+        os.environ.get,
+        (
+            "PROGRAMFILES",
+            "PROGRAMFILES(X86)",
+            "LOCALAPPDATA",
+            "PROGRAMW6432",
+        ),
+    ):
+        for subitem in (
+            "BraveSoftware/Brave-Browser/Application",
+        ):
+            try:
+                candidates.append(os.sep.join((item, subitem, "brave.exe")))
+            except TypeError:
+                pass
+    for candidate in candidates:
+        if os.path.exists(candidate) and os.access(candidate, os.X_OK):
+            return os.path.normpath(candidate)
+    return ""
+
+
+def comet_on_windows_path(browser_type=None):
+    if browser_type and browser_type != ChromeType.COMET:
+        return ""
+    if os_name() != OSType.WIN:
+        return ""
+    candidates = []
+    for item in map(
+        os.environ.get,
+        (
+            "LOCALAPPDATA",
+            "PROGRAMFILES",
+            "PROGRAMFILES(X86)",
+            "PROGRAMW6432",
+        ),
+    ):
+        for subitem in (
+            "Perplexity/Comet/Application",
+            "Comet/Application",
+            "Programs/Comet",
+        ):
+            try:
+                candidates.append(os.sep.join((item, subitem, "comet.exe")))
+            except TypeError:
+                pass
+    for candidate in candidates:
+        if os.path.exists(candidate) and os.access(candidate, os.X_OK):
+            return os.path.normpath(candidate)
+    return ""
+
+
+def atlas_on_windows_path(browser_type=None):
+    if browser_type and browser_type != ChromeType.ATLAS:
+        return ""
+    if os_name() != OSType.WIN:
+        return ""
+    candidates = []
+    for item in map(
+        os.environ.get,
+        (
+            "LOCALAPPDATA",
+            "PROGRAMFILES",
+            "PROGRAMFILES(X86)",
+            "PROGRAMW6432",
+        ),
+    ):
+        for subitem in (
+            "OpenAI/Atlas/Application",
+            "Atlas/Application",
+            "Programs/Atlas",
+        ):
+            try:
+                candidates.append(os.sep.join((item, subitem, "atlas.exe")))
+            except TypeError:
+                pass
+    for candidate in candidates:
+        if os.path.exists(candidate) and os.access(candidate, os.X_OK):
+            return os.path.normpath(candidate)
+    return ""
+
+
 def windows_browser_apps_to_cmd(*apps):
     """Create analogue of browser --version command for windows."""
     powershell = determine_powershell()
@@ -211,18 +423,48 @@ def windows_browser_apps_to_cmd(*apps):
 
 def get_binary_location(browser_type, chromium_ok=False):
     """Return the full path of the browser binary."""
+    if browser_type.lower() == "chrome":
+        browser_type = "google-chrome"
+    elif browser_type.lower() == "msedge":
+        browser_type = "edge"
+    else:
+        browser_type = browser_type.lower()
     cmd_mapping = {
         ChromeType.GOOGLE: {
-            OSType.LINUX: chrome_on_linux_path(chromium_ok),
+            OSType.LINUX: chrome_on_linux_path(chromium_ok, browser_type),
             OSType.MAC: r"/Applications/Google Chrome.app"
                         r"/Contents/MacOS/Google Chrome",
-            OSType.WIN: chrome_on_windows_path(),
+            OSType.WIN: chrome_on_windows_path(browser_type),
         },
         ChromeType.MSEDGE: {
-            OSType.LINUX: edge_on_linux_path(),
+            OSType.LINUX: edge_on_linux_path(browser_type),
             OSType.MAC: r"/Applications/Microsoft Edge.app"
                         r"/Contents/MacOS/Microsoft Edge",
-            OSType.WIN: edge_on_windows_path(),
+            OSType.WIN: edge_on_windows_path(browser_type),
+        },
+        ChromeType.OPERA: {
+            OSType.LINUX: opera_on_linux_path(browser_type),
+            OSType.MAC: r"/Applications/Opera.app"
+                        r"/Contents/MacOS/Opera",
+            OSType.WIN: opera_on_windows_path(browser_type),
+        },
+        ChromeType.BRAVE: {
+            OSType.LINUX: brave_on_linux_path(browser_type),
+            OSType.MAC: r"/Applications/Brave Browser.app"
+                        r"/Contents/MacOS/Brave Browser",
+            OSType.WIN: brave_on_windows_path(browser_type),
+        },
+        ChromeType.COMET: {
+            OSType.LINUX: comet_on_linux_path(browser_type),
+            OSType.MAC: r"/Applications/Comet.app"
+                        r"/Contents/MacOS/Comet",
+            OSType.WIN: comet_on_windows_path(browser_type),
+        },
+        ChromeType.ATLAS: {
+            OSType.LINUX: atlas_on_linux_path(browser_type),
+            OSType.MAC: r"/Applications/ChatGPT Atlas.app"
+                        r"/Contents/MacOS/ChatGPT Atlas",
+            OSType.WIN: atlas_on_windows_path(browser_type),
         },
     }
     return cmd_mapping[browser_type][os_name()]

seleniumbase/core/log_helper.py

@@ -1,4 +1,3 @@
-import codecs
 import os
 import shutil
 import sys
@@ -26,7 +25,7 @@ def log_screenshot(test_logpath, driver, screenshot=None, get=False):
     screenshot_skipped = constants.Warnings.SCREENSHOT_SKIPPED
     screenshot_warning = constants.Warnings.SCREENSHOT_UNDEFINED
     if (
-        (hasattr(sb_config, "no_screenshot") and sb_config.no_screenshot)
+        getattr(sb_config, "no_screenshot", None)
         or screenshot == screenshot_skipped
     ):
         if get:
@@ -37,7 +36,7 @@ def log_screenshot(test_logpath, driver, screenshot=None, get=False):
             element = driver.find_element("tag name", "body")
             screenshot = element.screenshot_as_base64
         if screenshot != screenshot_warning:
-            with open(screenshot_path, "wb") as file:
+            with open(screenshot_path, mode="wb") as file:
                 file.write(screenshot)
             with suppress(Exception):
                 shared_utils.make_writable(screenshot_path)
@@ -187,14 +186,10 @@ def log_test_failure_data(test, test_logpath, driver, browser, url=None):
     data_to_save.append(
         "--------------------------------------------------------------------"
     )
-    if (
-        hasattr(test, "_outcome")
-        and hasattr(test._outcome, "errors")
-        and test._outcome.errors
-    ):
+    if hasattr(test, "_outcome") and getattr(test._outcome, "errors", None):
         try:
-            exc_message = test._outcome.errors[0][1][1]
-            traceback_address = test._outcome.errors[0][1][2]
+            exc_message = test._outcome.errors[-1][1][1]
+            traceback_address = test._outcome.errors[-1][1][2]
             traceback_list = traceback.format_list(
                 traceback.extract_tb(traceback_address)[1:]
             )
@@ -226,12 +221,11 @@ def log_test_failure_data(test, test_logpath, driver, browser, url=None):
         data_to_save.append("Exception: %s" % exc_message)
     else:
         traceback_message = None
-        if hasattr(test, "is_behave") and test.is_behave:
+        if getattr(test, "is_behave", None):
             if sb_config.behave_scenario.status.name == "failed":
                 if (
                     hasattr(sb_config, "behave_step")
-                    and hasattr(sb_config.behave_step, "error_message")
-                    and sb_config.behave_step.error_message
+                    and getattr(sb_config.behave_step, "error_message", None)
                 ):
                     traceback_message = sb_config.behave_step.error_message
         else:
@@ -263,7 +257,7 @@ def log_test_failure_data(test, test_logpath, driver, browser, url=None):
                 )
             else:
                 message = None
-                if hasattr(test, "is_behave") and test.is_behave:
+                if getattr(test, "is_behave", None):
                     message = "Behave step was not implemented or skipped!"
                 else:
                     message = "Traceback not found!"
@@ -282,7 +276,7 @@ def log_test_failure_data(test, test_logpath, driver, browser, url=None):
                 data_to_save.append("Exception: %s" % sb_config._excinfo_value)
         else:
             data_to_save.append("Traceback:\n  %s" % traceback_message)
-    if hasattr(test, "is_nosetest") and test.is_nosetest:
+    if getattr(test, "is_nosetest", None):
         # Also save the data for the report
         sb_config._report_test_id = test_id
         sb_config._report_fail_page = last_page
@@ -298,7 +292,7 @@ def log_test_failure_data(test, test_logpath, driver, browser, url=None):
         with suppress(Exception):
             os.makedirs(test_logpath)
     with suppress(Exception):
-        log_file = codecs.open(basic_file_path, "w+", encoding="utf-8")
+        log_file = open(basic_file_path, mode="w+", encoding="utf-8")
         log_file.writelines("\r\n".join(data_to_save))
         log_file.close()
         shared_utils.make_writable(basic_file_path)
@@ -353,7 +347,7 @@ def log_skipped_test_data(test, test_logpath, driver, browser, reason):
     data_to_save.append("")
     file_path = os.path.join(test_logpath, "skip_reason.txt")
     with suppress(Exception):
-        log_file = codecs.open(file_path, "w+", encoding="utf-8")
+        log_file = open(file_path, mode="w+", encoding="utf-8")
         log_file.writelines("\r\n".join(data_to_save))
         log_file.close()
         shared_utils.make_writable(file_path)
@@ -388,14 +382,14 @@ def log_page_source(test_logpath, driver, source=None):
             os.makedirs(test_logpath)
     html_file_path = os.path.join(test_logpath, html_file_name)
     with suppress(Exception):
-        html_file = codecs.open(html_file_path, "w+", encoding="utf-8")
+        html_file = open(html_file_path, mode="w+", encoding="utf-8")
         html_file.write(page_source)
         html_file.close()
         shared_utils.make_writable(html_file_path)
 
 
 def get_test_id(test):
-    if hasattr(test, "is_behave") and test.is_behave:
+    if getattr(test, "is_behave", None):
         file_name = sb_config.behave_scenario.filename
         line_num = sb_config.behave_line_num
         scenario_name = sb_config.behave_scenario.name
@@ -403,7 +397,7 @@ def get_test_id(test):
             scenario_name = scenario_name.split(" -- @")[0]
         test_id = "%s:%s => %s" % (file_name, line_num, scenario_name)
         return test_id
-    elif hasattr(test, "is_context_manager") and test.is_context_manager:
+    elif getattr(test, "is_context_manager", None):
         filename = test.__class__.__module__.split(".")[-1] + ".py"
         classname = test.__class__.__name__
         methodname = test._testMethodName
@@ -413,7 +407,7 @@ def get_test_id(test):
 
             stack_base = traceback.format_stack()[0].split(", in ")[0]
             test_base = stack_base.split(", in ")[0].split(os.sep)[-1]
-            if hasattr(test, "cm_filename") and test.cm_filename:
+            if getattr(test, "cm_filename", None):
                 filename = test.cm_filename
             else:
                 filename = test_base.split('"')[0]

seleniumbase/core/mysql.py

@@ -42,7 +42,7 @@ class DatabaseManager:
         db_user = settings.DB_USERNAME
         db_pass = settings.DB_PASSWORD
         db_schema = settings.DB_SCHEMA
-        if hasattr(sb_config, "settings_file") and sb_config.settings_file:
+        if getattr(sb_config, "settings_file", None):
             override = settings_parser.set_settings(sb_config.settings_file)
             if "DB_HOST" in override.keys():
                 db_server = override["DB_HOST"]

seleniumbase/core/recorder_helper.py

@@ -556,6 +556,9 @@ def generate_sbase_code(srt_actions):
         elif action[0] == "ss_tl":
             method = "save_screenshot_to_logs"
             sb_actions.append("self.%s()" % method)
+        elif action[0] == "pdftl":
+            method = "save_as_pdf_to_logs"
+            sb_actions.append("self.%s()" % method)
         elif action[0] == "spstl":
             method = "save_page_source_to_logs"
             sb_actions.append("self.%s()" % method)

seleniumbase/core/report_helper.py

@@ -1,4 +1,3 @@
-import codecs
 import os
 import shutil
 import sys
@@ -48,7 +47,9 @@ def save_test_failure_data(test, name, folder=None):
         failure_data_file_path = os.path.join(file_path, name)
     else:
         failure_data_file_path = name
-    failure_data_file = codecs.open(failure_data_file_path, "w+", "utf-8")
+    failure_data_file = open(
+        failure_data_file_path, mode="w+", encoding="utf-8"
+    )
     data_to_save = []
     if not hasattr(sb_config, "_report_test_id"):
         exc_message = "(Unknown Exception)"
@@ -99,18 +100,14 @@ def process_failures(test, test_count, duration):
     bad_page_image = "failure_%s.png" % test_count
     bad_page_data = "failure_%s.txt" % test_count
     screenshot_path = os.path.join(LATEST_REPORT_DIR, bad_page_image)
-    if hasattr(test, "_last_page_screenshot") and test._last_page_screenshot:
-        with open(screenshot_path, "wb") as file:
+    if getattr(test, "_last_page_screenshot", None):
+        with open(screenshot_path, mode="wb") as file:
             file.write(test._last_page_screenshot)
     save_test_failure_data(test, bad_page_data, folder=LATEST_REPORT_DIR)
     exc_message = None
-    if (
-        hasattr(test, "_outcome")
-        and hasattr(test._outcome, "errors")
-        and test._outcome.errors
-    ):
+    if hasattr(test, "_outcome") and getattr(test._outcome, "errors", None):
         try:
-            exc_message = test._outcome.errors[0][1][1]
+            exc_message = test._outcome.errors[-1][1][1]
         except Exception:
             exc_message = "(Unknown Exception)"
     else:
@@ -173,7 +170,7 @@ def add_bad_page_log_file(page_results_list):
     abs_path = os.path.abspath(".")
     file_path = os.path.join(abs_path, LATEST_REPORT_DIR)
     log_file = os.path.join(file_path, RESULTS_TABLE)
-    f = open(log_file, "w")
+    f = open(log_file, mode="w")
     h_p1 = '"Num","Result","Stacktrace","Screenshot",'
     h_p2 = '"URL","Browser","Epoch Time","Duration",'
     h_p3 = '"Test Case Address","Additional Info"\n'
@@ -198,7 +195,7 @@ def add_results_page(html):
     file_path = os.path.join(abs_path, LATEST_REPORT_DIR)
     results_file_name = HTML_REPORT
     results_file = os.path.join(file_path, results_file_name)
-    f = open(results_file, "w")
+    f = open(results_file, mode="w")
     f.write(html)
     f.close()
     return results_file