seleniumbase 4.15.15__py3-none-any.whl → 4.16.0__py3-none-any.whl

seleniumbase/core/browser_launcher.py

@@ -1,7 +1,6 @@
 import fasteners
 import logging
 import os
-import platform
 import re
 import shutil
 import subprocess
@@ -16,17 +15,17 @@ from selenium.webdriver.common.service import utils as service_utils
 from selenium.webdriver.edge.service import Service as EdgeService
 from selenium.webdriver.firefox.service import Service as FirefoxService
 from selenium.webdriver.safari.service import Service as SafariService
+from seleniumbase import drivers  # webdriver storage folder for SeleniumBase
+from seleniumbase import extensions  # browser extensions storage folder
 from seleniumbase.config import settings
 from seleniumbase.core import download_helper
 from seleniumbase.core import proxy_helper
 from seleniumbase.fixtures import constants
 from seleniumbase.fixtures import shared_utils
-from seleniumbase import drivers  # webdriver storage folder for SeleniumBase
-from seleniumbase import extensions  # browser extensions storage folder
 
 urllib3.disable_warnings()
 selenium4_or_newer = False
-if sys.version_info[0] == 3 and sys.version_info[1] >= 7:
+if sys.version_info >= (3, 7):
     selenium4_or_newer = True
     from selenium.webdriver.common.options import ArgOptions
 
@@ -52,16 +51,6 @@ PROXY_ZIP_PATH = proxy_helper.PROXY_ZIP_PATH
 PROXY_ZIP_LOCK = proxy_helper.PROXY_ZIP_LOCK
 PROXY_DIR_PATH = proxy_helper.PROXY_DIR_PATH
 PROXY_DIR_LOCK = proxy_helper.PROXY_DIR_LOCK
-PLATFORM = sys.platform
-IS_ARM_MAC = False
-if (
-    "darwin" in PLATFORM
-    and (
-        "arm" in platform.processor().lower()
-        or "arm64" in platform.version().lower()
-    )
-):
-    IS_ARM_MAC = True
 LOCAL_CHROMEDRIVER = None
 LOCAL_GECKODRIVER = None
 LOCAL_EDGEDRIVER = None
@@ -69,21 +58,17 @@ LOCAL_IEDRIVER = None
 LOCAL_HEADLESS_IEDRIVER = None
 LOCAL_OPERADRIVER = None
 LOCAL_UC_DRIVER = None
-IS_WINDOWS = False
-IS_LINUX = False
-IS_MAC = False
-if "darwin" in PLATFORM or "linux" in PLATFORM:
+IS_ARM_MAC = shared_utils.is_arm_mac()
+IS_MAC = shared_utils.is_mac()
+IS_LINUX = shared_utils.is_linux()
+IS_WINDOWS = shared_utils.is_windows()
+if IS_MAC or IS_LINUX:
     LOCAL_CHROMEDRIVER = DRIVER_DIR + "/chromedriver"
     LOCAL_GECKODRIVER = DRIVER_DIR + "/geckodriver"
     LOCAL_EDGEDRIVER = DRIVER_DIR + "/msedgedriver"
     LOCAL_OPERADRIVER = DRIVER_DIR + "/operadriver"
     LOCAL_UC_DRIVER = DRIVER_DIR + "/uc_driver"
-    if "darwin" in PLATFORM:
-        IS_MAC = True
-    elif "linux" in PLATFORM:
-        IS_LINUX = True
-elif "win32" in PLATFORM or "win64" in PLATFORM or "x64" in PLATFORM:
-    IS_WINDOWS = True
+elif IS_WINDOWS:
     LOCAL_EDGEDRIVER = DRIVER_DIR + "/msedgedriver.exe"
     LOCAL_IEDRIVER = DRIVER_DIR + "/IEDriverServer.exe"
     LOCAL_HEADLESS_IEDRIVER = DRIVER_DIR + "/headless_ie_selenium.exe"
@@ -186,8 +171,8 @@ def uc_open(driver, url):
         and has_cf(requests_get(url).text)
     ):
         driver.execute_script('window.open("%s","_blank");' % url)
-        time.sleep(2.75)
-        driver.execute_script("window.close();")
+        driver.reconnect(2.65)
+        driver.close()
         driver.switch_to.window(driver.window_handles[-1])
     else:
         driver.open(url)  # The original one
@@ -822,6 +807,7 @@ def _set_chrome_options(
         )
     ):
         chrome_options.add_argument("--disable-popup-blocking")
+        chrome_options.add_argument("--homepage=chrome://new-tab-page/")
         # Skip remaining options that trigger anti-bot services
         return chrome_options
     chrome_options.add_argument("--test-type")
@@ -1128,7 +1114,7 @@ def get_driver(
                     "that has authentication! (If using a proxy server "
                     "without auth, Chrome, Edge, or Firefox may be used.)"
                 )
-        proxy_string = shared_utils.validate_proxy_string(proxy_string)
+        proxy_string = proxy_helper.validate_proxy_string(proxy_string)
         if proxy_string and proxy_user and proxy_pass:
             proxy_auth = True
     elif proxy_pac_url:

seleniumbase/core/capabilities_parser.py

@@ -9,16 +9,15 @@ def _analyze_ast(contents):
     except SyntaxError:
         pass
     try:
-        # remove all comments
+        # Remove all comments
         contents = re.sub(re.compile(r"/\*.*?\*/", re.DOTALL), "", contents)
         contents = re.sub(re.compile(r"#.*?\n"), "", contents)
 
-        # remove anything before dict declaration like: "caps = { ..."
+        # Remove anything before dict declaration like: "caps = { ..."
         match = re.match(r"^([^{]+)", contents)
         if match:
             contents = contents.replace(match.group(1), "")
 
-        # and try again
         return ast.literal_eval(contents)
     except SyntaxError:
         pass

seleniumbase/core/detect_b_ver.py

@@ -49,12 +49,11 @@ PATTERN = {
 
 
 def os_name():
-    pl = sys.platform
-    if pl == "linux" or pl == "linux2":
+    if "linux" in sys.platform:
         return OSType.LINUX
-    elif pl == "darwin":
+    elif "darwin" in sys.platform:
         return OSType.MAC
-    elif pl == "win32":
+    elif "win32" in sys.platform:
         return OSType.WIN
     else:
         raise Exception("Could not determine the OS type!")

seleniumbase/core/jqc_helper.py

@@ -1,7 +1,5 @@
-"""
-This module contains methods for opening jquery-confirm boxes.
-These helper methods SHOULD NOT be called directly from tests.
-"""
+"""This module contains methods for opening jquery-confirm boxes.
+These helper methods SHOULD NOT be called directly from tests."""
 from seleniumbase.fixtures import constants
 from seleniumbase.fixtures import js_utils
 

seleniumbase/core/mysql.py

@@ -1,4 +1,4 @@
-"""Wrapper for MySQL DB functions."""
+"""Wrapper for MySQL DB functions"""
 
 
 class DatabaseManager:

seleniumbase/core/proxy_helper.py

@@ -1,6 +1,11 @@
 import os
+import re
+import warnings
 import zipfile
+from seleniumbase.config import proxy_list
+from seleniumbase.config import settings
 from seleniumbase.fixtures import constants
+from seleniumbase.fixtures import page_utils
 
 DOWNLOADS_DIR = constants.Files.DOWNLOADS_FOLDER
 PROXY_ZIP_PATH = os.path.join(DOWNLOADS_DIR, "proxy.zip")
@@ -131,3 +136,63 @@ def remove_proxy_zip_if_present():
             os.remove(PROXY_ZIP_LOCK)
     except Exception:
         pass
+
+
+def validate_proxy_string(proxy_string):
+    if proxy_string in proxy_list.PROXY_LIST.keys():
+        proxy_string = proxy_list.PROXY_LIST[proxy_string]
+        if not proxy_string:
+            return None
+    valid = False
+    val_ip = re.match(
+        r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$", proxy_string
+    )
+    if not val_ip:
+        if proxy_string.startswith("http://"):
+            proxy_string = proxy_string.split("http://")[1]
+        elif proxy_string.startswith("https://"):
+            proxy_string = proxy_string.split("https://")[1]
+        elif "://" in proxy_string:
+            if not proxy_string.startswith("socks4://") and not (
+                proxy_string.startswith("socks5://")
+            ):
+                proxy_string = proxy_string.split("://")[1]
+        chunks = proxy_string.split(":")
+        if len(chunks) == 2:
+            if re.match(r"^\d+$", chunks[1]):
+                if page_utils.is_valid_url("http://" + proxy_string):
+                    valid = True
+        elif len(chunks) == 3:
+            if re.match(r"^\d+$", chunks[2]):
+                if page_utils.is_valid_url("http:" + ":".join(chunks[1:])):
+                    if chunks[0] == "http":
+                        valid = True
+                    elif chunks[0] == "https":
+                        valid = True
+                    elif chunks[0] == "socks4":
+                        valid = True
+                    elif chunks[0] == "socks5":
+                        valid = True
+    else:
+        proxy_string = val_ip.group()
+        valid = True
+    if not valid:
+        __display_proxy_warning(proxy_string)
+        proxy_string = None
+    return proxy_string
+
+
+def __display_proxy_warning(proxy_string):
+    message = (
+        '\nWARNING: Proxy String ["%s"] is NOT in the expected '
+        '"ip_address:port" or "server:port" format, '
+        "(OR the key does not exist in "
+        "seleniumbase.config.proxy_list.PROXY_LIST)." % proxy_string
+    )
+    if settings.RAISE_INVALID_PROXY_STRING_EXCEPTION:
+        raise Exception(message)
+    else:
+        message += " *** DEFAULTING to NOT USING a Proxy Server! ***"
+        warnings.simplefilter("always", Warning)  # See Warnings
+        warnings.warn(message, category=Warning, stacklevel=2)
+        warnings.simplefilter("default", Warning)  # Set Default

seleniumbase/core/recorder_helper.py

@@ -1,4 +1,4 @@
-"""Generating SeleniumBase Python code from the Recorder."""
+"""Generating SeleniumBase Python code from the Recorder"""
 
 
 def generate_sbase_code(srt_actions):

seleniumbase/core/s3_manager.py

@@ -24,19 +24,20 @@ class S3LoggingBucket(object):
         )
         with pip_find_lock:
             try:
-                from boto.s3.connection import S3Connection
+                import boto3
             except Exception:
-                shared_utils.pip_install("boto", version="2.49.0")
-                from boto.s3.connection import S3Connection
-        self.conn = S3Connection(selenium_access_key, selenium_secret_key)
-        self.bucket = self.conn.get_bucket(log_bucket)
+                shared_utils.pip_install("boto3")
+                import boto3
+        self.conn = boto3.Session(
+            aws_access_key_id=selenium_access_key,
+            aws_secret_access_key=selenium_secret_key,
+        )
+        self.bucket = log_bucket
         self.bucket_url = bucket_url
 
     def get_key(self, file_name):
-        """Create a new Key instance with the given name."""
-        from boto.s3.key import Key
-
-        return Key(bucket=self.bucket, name=file_name)
+        """Create a new S3 connection instance with the given name."""
+        return self.conn.resource("s3").Object(self.bucket, file_name)
 
     def get_bucket(self):
         """Return the bucket being used."""
@@ -53,18 +54,19 @@ class S3LoggingBucket(object):
             content_type = "image/jpeg"
         elif file_name.endswith(".png"):
             content_type = "image/png"
-        upload_key.set_contents_from_filename(
-            file_path, headers={"Content-Type": content_type}
+        upload_key.Bucket().upload_file(
+            file_path,
+            file_name,
+            ExtraArgs={"ACL": "public-read", "ContentType": content_type},
         )
-        upload_key.url = upload_key.generate_url(expires_in=3600).split("?")[0]
-        try:
-            upload_key.make_public()
-        except Exception:
-            pass
 
-    def upload_index_file(self, test_address, timestamp):
+    def upload_index_file(
+        self, test_address, timestamp, data_path, save_data_to_logs
+    ):
         """Create an index.html file with links to all the log files
         that were just uploaded."""
+        import os
+
         global already_uploaded_files
         already_uploaded_files = list(set(already_uploaded_files))
         already_uploaded_files.sort()
@@ -76,15 +78,19 @@ class S3LoggingBucket(object):
                 "<a href='" + self.bucket_url + ""
                 "%s'>%s</a>" % (completed_file, completed_file)
             )
-        index.set_contents_from_string(
-            "<br>".join(index_str), headers={"Content-Type": "text/html"}
+        index_page = str("<br>".join(index_str))
+        save_data_to_logs(index_page, "index.html")
+        file_path = os.path.join(data_path, "index.html")
+        index.Bucket().upload_file(
+            file_path,
+            file_name,
+            ExtraArgs={"ACL": "public-read", "ContentType": "text/html"},
         )
-        index.make_public()
         return "%s%s" % (self.bucket_url, file_name)
 
     def save_uploaded_file_names(self, files):
-        """Keep a record of all file names that have been uploaded. Upload log
-        files related to each test after its execution. Once done, use
-        already_uploaded_files to create an index file."""
+        """Keep a record of all file names that have been uploaded.
+        Upload log files related to each test after its execution.
+        Once done, use already_uploaded_files to create an index file."""
         global already_uploaded_files
         already_uploaded_files.extend(files)

seleniumbase/core/session_helper.py

@@ -1,9 +1,5 @@
-import sys
 from seleniumbase import config as sb_config
-
-is_windows = False
-if sys.platform in ["win32", "win64", "x64"]:
-    is_windows = True
+from seleniumbase.fixtures import shared_utils
 
 
 def end_reused_class_session_as_needed():
@@ -14,7 +10,7 @@ def end_reused_class_session_as_needed():
         and sb_config.shared_driver
     ):
         if (
-            not is_windows
+            not shared_utils.is_windows()
             or (
                 hasattr(sb_config.shared_driver, "service")
                 and sb_config.shared_driver.service.process

seleniumbase/core/settings_parser.py

@@ -75,6 +75,8 @@ def set_settings(settings_file):
             settings.ARCHIVE_EXISTING_LOGS = override_settings[key]
         elif key == "ARCHIVE_EXISTING_DOWNLOADS":
             settings.ARCHIVE_EXISTING_DOWNLOADS = override_settings[key]
+        elif key == "SCREENSHOT_WITH_BACKGROUND":
+            settings.SCREENSHOT_WITH_BACKGROUND = override_settings[key]
         elif key == "SCREENSHOT_NAME":
             settings.SCREENSHOT_NAME = override_settings[key]
         elif key == "BASIC_INFO_NAME":

seleniumbase/fixtures/base_case.py

@@ -65,6 +65,7 @@ from seleniumbase.common.exceptions import (
     NotConnectedException,
     NotUsingChromeException,
     NotUsingChromiumException,
+    ProxyConnectionException,
     OutOfScopeException,
     VisualException,
 )
@@ -87,9 +88,7 @@ logging.getLogger("requests").setLevel(logging.ERROR)
 logging.getLogger("urllib3").setLevel(logging.ERROR)
 urllib3.disable_warnings()
 LOGGER.setLevel(logging.WARNING)
-is_windows = False
-if sys.platform in ["win32", "win64", "x64"]:
-    is_windows = True
+is_windows = shared_utils.is_windows()
 python3_11_or_newer = False
 if sys.version_info >= (3, 11):
     python3_11_or_newer = True
@@ -263,6 +262,7 @@ class BaseCase(unittest.TestCase):
             elif (
                 "ERR_INTERNET_DISCONNECTED" in e.msg
                 or "neterror?e=dnsNotFound" in e.msg
+                or "ERR_PROXY_CONNECTION_FAILED" in e.msg
             ):
                 shared_utils.check_if_time_limit_exceeded()
                 self.__check_browser()
@@ -274,8 +274,13 @@ class BaseCase(unittest.TestCase):
                         "ERR_INTERNET_DISCONNECTED" in e2.msg
                         or "neterror?e=dnsNotFound" in e2.msg
                     ):
-                        message = "Internet unreachable!"
+                        message = "ERR_INTERNET_DISCONNECTED: "
+                        message += "Internet unreachable!"
                         raise NotConnectedException(message)
+                    elif "ERR_PROXY_CONNECTION_FAILED" in e2.msg:
+                        message = "ERR_PROXY_CONNECTION_FAILED: "
+                        message += "Internet unreachable and/or invalid proxy!"
+                        raise ProxyConnectionException(message)
                     else:
                         raise
             elif "Timed out receiving message from renderer" in e.msg:
@@ -7266,6 +7271,11 @@ class BaseCase(unittest.TestCase):
         """Return True if the url is a valid url."""
         return page_utils.is_valid_url(url)
 
+    def is_online(self):
+        """Return True if connected to the Internet."""
+        online = self.execute_script("return navigator.onLine;")
+        return online
+
     def is_chromium(self):
         """Return True if the browser is Chrome, Edge, or Opera."""
         self.__check_scope()
@@ -13676,11 +13686,9 @@ class BaseCase(unittest.TestCase):
                 )
                 from seleniumbase.core.testcase_manager import (
                     ExecutionQueryPayload,
-                )
-                from seleniumbase.core.testcase_manager import (
                     TestcaseDataPayload,
+                    TestcaseManager,
                 )
-                from seleniumbase.core.testcase_manager import TestcaseManager
 
                 self.execution_guid = str(uuid.uuid4())
                 self.testcase_guid = None
@@ -14027,7 +14035,17 @@ class BaseCase(unittest.TestCase):
                         ignore_test_time_limit=True,
                     )
                 try:
-                    self.__last_page_screenshot = element.screenshot_as_base64
+                    if (
+                        hasattr(settings, "SCREENSHOT_WITH_BACKGROUND")
+                        and settings.SCREENSHOT_WITH_BACKGROUND
+                    ):
+                        self.__last_page_screenshot = (
+                            self.driver.get_screenshot_as_base64()
+                        )
+                    else:
+                        self.__last_page_screenshot = (
+                            element.screenshot_as_base64
+                        )
                 except Exception:
                     try:
                         self.__last_page_screenshot = (
@@ -15178,16 +15196,16 @@ class BaseCase(unittest.TestCase):
                     )
                     uploaded_files.append(logfile_name)
                 s3_bucket.save_uploaded_file_names(uploaded_files)
-                index_file = s3_bucket.upload_index_file(test_id, guid)
-                print("\n\n*** Log files uploaded: ***\n%s\n" % index_file)
+                index_file = s3_bucket.upload_index_file(
+                    test_id, guid, self.data_path, self.save_data_to_logs
+                )
+                print("\n*** Log files uploaded: ***\n%s\n" % index_file)
                 logging.info(
-                    "\n\n*** Log files uploaded: ***\n%s\n" % index_file
+                    "\n*** Log files uploaded: ***\n%s\n" % index_file
                 )
                 if self.with_db_reporting:
                     from seleniumbase.core.testcase_manager import (
                         TestcaseDataPayload,
-                    )
-                    from seleniumbase.core.testcase_manager import (
                         TestcaseManager,
                     )
 

seleniumbase/fixtures/constants.py

@@ -1,4 +1,4 @@
-"""SeleniumBase constants are stored in this file."""
+"""SeleniumBase constants"""
 from seleniumbase.core import encoded_images
 
 

seleniumbase/fixtures/css_to_xpath.py

@@ -6,8 +6,7 @@ class ConvertibleToCssTranslator(GenericTranslator):
     """An implementation of :py:class:`cssselect.GenericTranslator` with
     XPath output that more readily converts back to CSS selectors.
     The simplified examples in https://devhints.io/xpath were used as a
-    reference here.
-    """
+    reference here."""
 
     def css_to_xpath(self, css, prefix="//"):
         return super().css_to_xpath(css, prefix)

seleniumbase/fixtures/errors.py

@@ -1,28 +1,23 @@
-"""
-SeleniumBase MySQL-related exceptions.
+"""SeleniumBase MySQL-related exceptions.
 
 This feature is DEPRECATED!
 Use self.skip() for skipping tests!
 
 Raising one of these in a test will cause the
 test-state to be logged appropriately in the DB
-for tests that use the SeleniumBase MySQL option.
-"""
+for tests that use the SeleniumBase MySQL option."""
 
 
 class BlockedTest(Exception):
     """Raise this to mark a test as Blocked in the DB."""
-
     pass
 
 
 class SkipTest(Exception):
     """Raise this to mark a test as Skipped in the DB."""
-
     pass
 
 
 class DeprecatedTest(Exception):
     """Raise this to mark a test as Deprecated in the DB."""
-
     pass

seleniumbase/fixtures/js_utils.py

@@ -1,7 +1,4 @@
-"""
-This module contains useful Javascript utility methods for base_case.py
-These helper methods SHOULD NOT be called directly from tests.
-"""
+"""This module contains useful Javascript utility methods for BaseCase."""
 import re
 import requests
 import time
@@ -13,16 +10,14 @@ from seleniumbase.fixtures import constants
 
 
 def wait_for_ready_state_complete(driver, timeout=settings.LARGE_TIMEOUT):
-    """
-    The DOM (Document Object Model) has a property called "readyState".
+    """The DOM (Document Object Model) has a property called "readyState".
     When the value of this becomes "complete", page resources are considered
       fully loaded (although AJAX and other loads might still be happening).
     This method will wait until document.readyState == "complete".
     This may be redundant, as methods already wait for page elements to load.
     If the timeout is exceeded, the test will still continue
       because readyState == "interactive" may be good enough.
-    (Previously, tests would fail immediately if exceeding the timeout.)
-    """
+    (Previously, tests would fail immediately if exceeding the timeout.)"""
     if hasattr(settings, "SKIP_JS_WAITS") and settings.SKIP_JS_WAITS:
         return
     if sb_config.time_limit and not sb_config.recorder_mode:
@@ -157,8 +152,8 @@ def raise_unable_to_load_jquery_exception(driver):
 
 
 def activate_jquery(driver):
-    """If "jQuery is not defined" on a website, use this method to activate it.
-    This method is needed because jQuery is not always defined on web sites."""
+    # If "jQuery is not defined" on a website, use this method to activate it.
+    # This method is needed because jQuery is not always defined on web sites.
     try:
         # Let's first find out if jQuery is already defined.
         driver.execute_script("jQuery('html');")
@@ -191,8 +186,7 @@ def are_quotes_escaped(string):
 
 
 def escape_quotes_if_needed(string):
-    """
-    re.escape() works differently in Python 3.7.0 than earlier versions:
+    """re.escape() works differently in Python 3.7.0 than earlier versions:
 
     Python 3.6.5:
     >>> import re
@@ -215,10 +209,8 @@ def escape_quotes_if_needed(string):
 
 
 def is_in_frame(driver):
-    """
-    Returns True if the driver has switched to a frame.
-    Returns False if the driver was on default content.
-    """
+    # Returns True if the driver has switched to a frame.
+    # Returns False if the driver was on default content.
     in_basic_frame = driver.execute_script(
         """
         var frame = window.frameElement;

seleniumbase/fixtures/page_actions.py

@@ -1,12 +1,10 @@
-"""
-This module contains a set of methods that can be used for page loads and
-for waiting for elements to appear on a page.
+"""This module contains useful methods for waiting on elements to load.
 
-These methods improve on and expand existing WebDriver commands.
+These methods improve and expand on existing WebDriver commands.
 Improvements include making WebDriver commands more robust and more reliable
 by giving page elements enough time to load before taking action on them.
 
-The default option for searching for elements is by CSS Selector.
+The default option for searching for elements is by "css selector".
 This can be changed by overriding the "By" parameter from this import:
 > from selenium.webdriver.common.by import By
 Options are:
@@ -19,7 +17,6 @@ By.XPATH               # "xpath"
 By.TAG_NAME            # "tag name"
 By.PARTIAL_LINK_TEXT   # "partial link text"
 """
-
 import codecs
 import os
 import time

seleniumbase/fixtures/page_utils.py

@@ -1,4 +1,4 @@
-"""This module contains useful utility methods."""
+"""This module contains useful utility methods"""
 import codecs
 import fasteners
 import os