Code Vibes

Python

Automating Tasks with Python: Using Selenium for Browser Automation

Ethan Brown

In today’s digital landscape, the efficiency and speed provided by automation are more crucial than ever. Python, with its robust libraries, stands out as a powerhouse for such tasks. One of the most potent combinations is Python with Selenium, which offers extensive possibilities for browser automation. Whether you’re a novice venturing into the realm of Python coding for automation or a seasoned developer seeking to streamline your workflow, this article will serve as your comprehensive guide. Here, we will delve into the essentials of using Selenium for browser automation, showcasing practical examples and insights to help you master this invaluable tool.

Introduction to Python Browser Automation

In the fast-paced world of information technology, efficiency and automation are the cornerstones of success. One of the pivotal tools in the realm of browser automation is Selenium WebDriver, and Python, being known for its simplicity and readability, perfectly complements Selenium for creating powerful automation scripts. This synergy between Python and Selenium allows developers and QA testers to automate web browser actions, saving time and reducing human error in repetitive tasks.

Browser automation involves a sequence of operations designed to interact with web browsers programmatically. With Python and Selenium, these operations can range from simple tasks like filling out forms and clicking buttons, to more complex workflows like scraping data or automated testing. The flexibility of Python, combined with Selenium’s capabilities, makes them a dynamic duo in the world of web automation.

One of the core components of Selenium is the WebDriver API, which provides a programming interface to create and manage browser automation tasks. WebDriver supports various web browsers such as Chrome, Firefox, Edge, and Safari, ensuring that scripts are not limited to a specific environment. This cross-browser capability is particularly beneficial for developers and testers who need to ensure their web applications perform consistently across different browsers.

To illustrate the practical implementation of Selenium with Python, here’s a simple example that demonstrates how to open a browser and navigate to a specific website:

from selenium import webdriver

# Initialize the WebDriver - here we use Chrome
driver = webdriver.Chrome(executable_path='/path/to/chromedriver')

# Open a specific URL
driver.get('https://www.example.com')

# Perform further actions like finding elements, clicking buttons, etc.
# Example: Finding an element and clicking it
element = driver.find_element_by_id('element_id')
element.click()

# Close the browser
driver.quit()

In this snippet, the webdriver.Chrome class is used to create an instance of the Chrome browser. The get method is called to navigate to https://www.example.com, and the find_element_by_id method locates an element by its ID to perform an action, such as clicking it. Finally, the quit method closes the browser.

Selenium WebDriver for Python is well-documented, with comprehensive resources available to help developers get started and overcome obstacles. The official Selenium documentation (https://www.selenium.dev/documentation/en/) is an excellent starting point, providing in-depth details on setup, usage, and advanced features.

While Python and Selenium are an excellent combination for browser automation, it’s worth mentioning alternative tools that serve similar purposes. For instance, frameworks like Puppeteer (for Node.js) or Playwright offer powerful automation capabilities but require knowledge of JavaScript. Despite these alternatives, Selenium remains one of the most popular due to its language support, extensive community, and robust features.

In the subsequent sections, we will delve deeper into setting up your environment, creating simple and advanced automations, and exploring real-world examples. By the end of our journey, you’ll be equipped with the knowledge and skills to leverage Python and Selenium for efficient browser automation.

Getting Started with Selenium WebDriver in Python

To begin your journey into Selenium automation with Python, the first step involves getting familiar with Selenium WebDriver. Selenium WebDriver is a powerful tool for controlling web browsers through programs and performing browser automation. Here’s a step-by-step guide on how to get started with Selenium WebDriver in Python.

Installing Selenium and WebDriver

Before you can start using Selenium WebDriver, you need to install the Selenium package and the WebDriver for the browser you intend to automate. You can install Selenium using pip:

pip install selenium

Next, you’ll need the WebDriver specific to your target browser. For instance, if you’re automating tasks in Google Chrome, you need to download ChromeDriver from the official site: ChromeDriver.

Setting Up WebDriver

Once downloaded, you need to configure the path to your WebDriver. Here’s how you can integrate it within your Python script:

from selenium import webdriver

# Define the path to the ChromeDriver executable
driver_path = '/path/to/chromedriver'

# Initialize the WebDriver
driver = webdriver.Chrome(executable_path=driver_path)

Make sure you replace /path/to/chromedriver with the actual path where you saved the ChromeDriver executable.

Basic Navigation

After setting up the WebDriver, you can start writing scripts to automate browser actions. For instance, here’s a simple example demonstrating how to navigate to a website:

# Open a specific URL
driver.get("https://www.example.com")

# Print the title of the web page
print(driver.title)

Interacting with Web Elements

WebDriver allows you to interact with various web elements such as buttons, input fields, and other interactive components. Below is an example where we find a search input field by its name attribute and submit a query:

from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys

# Locate element by name and input a search term
search_box = driver.find_element(By.NAME, 'q')
search_box.send_keys('Selenium WebDriver')

# Submit the search query
search_box.send_keys(Keys.RETURN)

# Extract and print search results
results = driver.find_elements(By.CSS_SELECTOR, '.r a')
for result in results:
    print(result.text)

Waiting for Elements

Sometimes, you may need to wait for certain elements to load before interacting with them. Selenium WebDriver provides explicit and implicit waits. Here’s how you can use WebDriverWait for an explicit wait:

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Example of an explicit wait
try:
    element = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, "element_id"))
    )
finally:
    driver.quit()

In this snippet, the script waits up to 10 seconds before throwing an exception if the element is not found.

Closing the Browser

At the end of your script, it’s good practice to close the browser window properly:

# Close the browser window
driver.quit()

By following these steps, you’ll have a solid foundation to start automating tasks using Selenium WebDriver in Python. You can further explore Selenium’s official documentation for more extensive details and advanced configurations.

Setting Up Your Python Environment for Selenium

To get started with Selenium for browser automation in Python, the first step is to set up your Python environment. This involves installing necessary tools and libraries, configuring the WebDriver, and ensuring that your system is ready for automation tasks. Here’s a detailed guide on how to achieve this:

Step 1: Install Python and Pip

Ensure Python is installed on your system. You can download the latest version from the official Python website. After installing Python, verify the installation by running:

python --version

Similarly, ensure that Pip, the package installer for Python, is installed. This typically comes bundled with Python, but you can check with:

pip --version

Step 2: Set Up a Virtual Environment

Creating a virtual environment is a good practice to keep your project dependencies isolated. To create and activate a virtual environment, use:

# Create a virtual environment
python -m venv selenium-env

# Activate the virtual environment
# On Windows
selenium-env\Scripts\activate

# On macOS/Linux
source selenium-env/bin/activate

Step 3: Install Selenium

With the virtual environment activated, install the Selenium package using Pip:

pip install selenium

This will install the necessary Selenium libraries that enable browser automation with Python.

Step 4: Download a WebDriver

Selenium requires a WebDriver to interact with your chosen browser. The WebDriver acts as a bridge between Selenium scripts and the web browser. Common WebDrivers include:

  • ChromeDriver for Google Chrome
  • GeckoDriver for Mozilla Firefox

Download the corresponding driver from the following links:

Place the downloaded WebDriver executable into a directory that is included in your system’s PATH, or specify its location directly in your scripts.

Step 5: Verify Installation

Write a simple Python script to verify that everything is set up correctly. Create a file named test_setup.py:

from selenium import webdriver

# Initialize the Chrome WebDriver
driver = webdriver.Chrome()

# Open a webpage
driver.get('https://www.python.org')

# Print the title
print(driver.title)

# Close the browser
driver.quit()

Run the script:

python test_setup.py

If the script opens a Chrome browser window and prints the Python website title, your environment is successfully set up for Selenium automation with Python.

Step 6: Managing Dependencies

To ensure your project is reproducible, create a requirements.txt file:

pip freeze > requirements.txt

This file lists all the dependencies required for your project. You can use it to recreate your environment:

pip install -r requirements.txt

Refer to the official Selenium documentation for more detailed information about setting up and using Selenium for browser automation with Python.

By following these steps, you will have a properly configured Python environment ready for writing Selenium scripts and automating your web tasks. This setup acts as a foundation to build further on, allowing you to leverage advanced techniques and real-world automation scenarios in subsequent sections of this guide.

Creating Simple Automations with Selenium and Python

To get started with creating simple automations using Selenium and Python, you first need a basic understanding of interacting with web elements such as buttons, input fields, and navigating through different pages. Here’s how you can achieve common automation tasks:

Installing Necessary Packages

First, ensure that you have the appropriate packages installed. You will need both Selenium and a web driver like chromedriver for Chrome.

pip install selenium

Download the appropriate web driver and ensure it’s in your system’s PATH. For example, you can download chromedriver from ChromeDriver – WebDriver for Chrome.

Basic Script Structure

A simple Selenium script typically follows these steps:

  1. Import necessary modules.
  2. Initialize the WebDriver.
  3. Navigate to a web page.
  4. Interact with web elements.

For example, here’s a simple script that opens a webpage, finds an element by its name, and inputs text into it:

from selenium import webdriver
from selenium.webdriver.common.keys import Keys

# Initialize the WebDriver
driver = webdriver.Chrome()

# Navigate to a URL
driver.get('http://www.google.com')

# Locate the search box element by its name attribute
search_box = driver.find_element_by_name('q')

# Input text into the search box
search_box.send_keys('Selenium Python examples')

# Simulate hitting the Enter key
search_box.send_keys(Keys.RETURN)

# Make the WebDriver wait for a few seconds to see the result page
driver.implicitly_wait(5)

# Close the WebDriver instance
driver.quit()

Filling Out Forms

To automate tasks like form submissions, you can use the send_keys method to input text and the click method to submit forms.

from selenium import webdriver

driver = webdriver.Chrome()

# Navigate to a URL
driver.get('http://example.com/login')

# Locate the form fields
username_field = driver.find_element_by_name('username')
password_field = driver.find_element_by_name('password')

# Enter text into the fields
username_field.send_keys('your_username')
password_field.send_keys('your_password')

# Locate the submit button and click it
submit_button = driver.find_element_by_id('submit')
submit_button.click()

# Close the WebDriver instance
driver.quit()

Clicking Buttons and Links

Interacting with buttons and links is straightforward. You often locate the element and then call the click method.

driver = webdriver.Chrome()
driver.get('http://example.com')

# Locate the button by its ID and click it
button = driver.find_element_by_id('button_id')
button.click()

# Close the WebDriver instance
driver.quit()

Handling Dropdowns

Dropdown menus can be managed using the Select class from selenium.webdriver.support.ui.

from selenium.webdriver.support.ui import Select

driver = webdriver.Chrome()
driver.get('http://example.com')

# Locate the dropdown element
dropdown = Select(driver.find_element_by_name('dropdown_name'))

# Select by visible text
dropdown.select_by_visible_text('OptionText')

# Or, select by value
dropdown.select_by_value('OptionValue')

# Close the WebDriver instance
driver.quit()

Handling Alerts

If your automation script needs to handle pop-up alerts, use the switch_to.alert method.

driver = webdriver.Chrome()
driver.get('http://example.com')

# Trigger some action that causes an alert to be displayed
driver.find_element_by_id('trigger-alert-button').click()

# Switch the WebDriver context to the alert
alert = driver.switch_to.alert

# Accept the alert
alert.accept()

# Close the WebDriver instance
driver.quit()

By leveraging these basic interactions, you can automate a variety of repetitive web tasks, freeing up valuable time for more important work. These examples just scratch the surface of what you can achieve with Selenium and Python. For more detailed information, the Selenium official documentation is a great resource: Selenium Documentation.

Advanced Techniques in Selenium Scripting with Python

Advanced Techniques in Selenium Scripting with Python

When you’ve mastered the basics of Selenium scripting in Python, it’s time to delve deeper into advanced techniques that can significantly elevate the capabilities and performance of your browser automation tasks. This section will explore some sophisticated methods, ensuring your automation scripts are robust, efficient, and maintainable.

Handling Dynamic Web Elements with Explicit Waits

Web pages often contain dynamic content that can load or change after the initial page load. Using Explicit Waits to handle these dynamic elements can prevent race conditions and improve script reliability.

The WebDriverWait class in Selenium allows you to define the maximum time to wait for a condition to be met:

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver.get("http://example.com/dynamic_content")
try:
    element = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, "dynamicElement"))
    )
    element.click()
except TimeoutException:
    print("Element not found within the specified timeout")

For more details, refer to the Explicit Waits section of the Selenium documentation.

Using Selenium with Headless Browsers for Performance

Running Selenium tests in a headless mode—where the browser operates without a GUI—can drastically reduce the resources required and increase the speed of your scripts. Headless browsers like Headless Chrome or Headless Firefox are ideal for CI/CD pipelines and environments where you don’t need visuals.

To start a headless Chrome instance:

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options

chrome_options = Options()
chrome_options.add_argument("--headless")
chrome_options.add_argument("--disable-gpu")

service = Service('path/to/chromedriver')
driver = webdriver.Chrome(service=service, options=chrome_options)
driver.get('http://example.com')
print(driver.title)
driver.quit()

For more information, you can explore the Google Chrome headless documentation.

Automating File Downloads

Selenium can be configured to handle file downloads automatically, saving time and effort. For example, you can direct Chrome to download files to a specific directory without asking for confirmation:

chrome_options = Options()
prefs = {
    "download.default_directory": "/path/to/download",
    "download.prompt_for_download": False,
    "directory_upgrade": True,
    "plugins.always_open_pdf_externally": True
}
chrome_options.add_experimental_option("prefs", prefs)

driver = webdriver.Chrome(service=service, options=chrome_options)
driver.get('http://example.com/download_page')
download_button = driver.find_element(By.ID, 'downloadButton')
download_button.click()

This method can be fine-tuned for other types of files or for different browsers. Refer to the Selenium documentation on file downloads for comprehensive instructions.

Executing JavaScript with Selenium

Sometimes, interacting with web elements directly using Python APIs may not be sufficient. Executing JavaScript can provide a way to interact more deeply with the web page elements. You can run JavaScript commands directly within your Selenium scripts to manipulate the DOM, fetch elements, or trigger events:

driver.execute_script("return document.title;")

button = driver.execute_script("return document.getElementById('buttonId');")
button.click()

For more detailed examples, check the official Selenium documentation on JavaScript execution.

Integrating Page Object Model (POM)

The Page Object Model (POM) is a design pattern in Selenium that encapsulates elements, actions, and tests for a web page in classes, making your automation scripts more modular and maintainable. Each web page or part of a web page is represented by a class, with locators as class variables and interactions as class methods.

Example of a simple POM for a login page:

class LoginPage:
    def __init__(self, driver):
        self.driver = driver
        self.username_field = (By.ID, 'username')
        self.password_field = (By.ID, 'password')
        self.login_button = (By.ID, 'loginButton')
    
    def enter_username(self, username):
        user_box = self.driver.find_element(*self.username_field)
        user_box.send_keys(username)
    
    def enter_password(self, password):
        pass_box = self.driver.find_element(*self.password_field)
        pass_box.send_keys(password)
    
    def click_login_button(self):
        self.driver.find_element(*self.login_button).click()

By structuring your scripts this way, you can maintain cleaner and more scalable test code. For comprehensive details, review the Page Object Model article on Selenium’s wiki.

These techniques in Selenium automation with Python can greatly enhance the robustness and performance of your scripts, making them more adaptable to complex and dynamic web applications.

Best Practices and Troubleshooting in Selenium Automation

To efficiently use Selenium for browser automation in Python, adhering to best practices is crucial for optimizing performance, ensuring stability, and maintaining code readability. Below are some best practices and troubleshooting techniques to enhance your Selenium automation projects:

Best Practices

1. Implicit vs. Explicit Waits

Using waits correctly can handle dynamic content and elements that load asynchronously. While implicit waits set a general wait time, explicit waits provide more control:

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome()
driver.get("http://example.com")

# Explicit wait
element = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "myElement"))
)

Reliable waits help avoid flaky tests and ensure elements are available before interaction.

2. Page Object Model (POM)

Implementing POM enhances code robustness and reusability by separating the code that handles browser interactions from the logic. Define a class for each page:

class LoginPage:
    def __init__(self, driver):
        self.driver = driver
        self.username_field = (By.ID, "username")
        self.password_field = (By.ID, "password")
        self.login_button = (By.ID, "loginBtn")

    def login(self, username, password):
        self.driver.find_element(*self.username_field).send_keys(username)
        self.driver.find_element(*self.password_field).send_keys(password)
        self.driver.find_element(*self.login_button).click()

3. Browser Drivers Management

Ensuring compatibility between the browser driver and the browser itself is essential. Regularly update WebDriver and manage driver versions using tools like webdriver-manager:

from selenium import webdriver
from webdriver_manager.chrome import ChromeDriverManager

driver = webdriver.Chrome(ChromeDriverManager().install())

4. Headless Browser Mode

For CI/CD integration or environments without graphical interfaces, use a headless browser to save resources:

options = webdriver.ChromeOptions()
options.add_argument('--headless')
driver = webdriver.Chrome(options=options)

Troubleshooting Techniques

1. Debugging with Screenshots

Capture screenshots upon test failure to analyze the state of the browser when the error occurred:

try:
    # your test code here
except Exception as e:
    driver.save_screenshot('screenshot.png')
    raise e

2. Handling StaleElementReferenceException

Elements on a page might change after interactions, leading to stale references. Re-locate elements as needed:

from selenium.common.exceptions import StaleElementReferenceException

try:
    element = driver.find_element(By.ID, "dynamicElement")
    # perform actions
except StaleElementReferenceException:
    element = driver.find_element(By.ID, "dynamicElement")
    # retry actions

3. Mitigating Modal and Popup Issues

Modal windows or popups can obstruct browser interactions. Use expected conditions to handle interruptions:

WebDriverWait(driver, 10).until(EC.alert_is_present())

alert = driver.switch_to.alert
alert.accept()  # or .dismiss() for dismissing the alert

4. Logging

Effective logging provides insights during test execution:

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

logger.info("Navigating to the login page")
driver.get("http://example.com")

Conclusion

Apply these best practices and troubleshooting techniques to ensure efficient and maintainable Selenium automation scripts. Effective use of waits, design patterns like POM, driver management, and debugging strategies will substantially improve the robustness and readability of your automation code.

Real-World Selenium Python Examples for Web Automation

To understand the full potential of Selenium in Python, it’s helpful to look at some concrete, real-world examples. Let’s delve into a few scenarios where Selenium can streamline everyday tasks by automating them.

Logging into a Website

One of the most common tasks for Selenium is automating the login process for websites. Below, we’ll demonstrate how to log in to a website using Selenium and Python:

from selenium import webdriver
from selenium.webdriver.common.keys import Keys

# Initialize WebDriver, you need to specify the path to the WebDriver executable
driver = webdriver.Chrome(executable_path='/path/to/chromedriver')

try:
    # Open the login page
    driver.get("https://example.com/login")
    
    # Find username and password fields and enter your credentials
    username_field = driver.find_element_by_name("username")
    password_field = driver.find_element_by_name("password")
    
    username_field.send_keys("yourUsername")
    password_field.send_keys("yourPassword")
    
    # Submit the form
    password_field.send_keys(Keys.RETURN)
    
    # Adding a wait to ensure the new page loads
    driver.implicitly_wait(10)
    
    # Print the title of the page to verify the successful login
    print(driver.title)
    
finally:
    # Close the browser
    driver.quit()

Documentation: Selenium WebDriver Waits

Scraping Data from a Web Page

Another useful application of Selenium with Python is scraping data from websites. For example, automating the process of retrieving the latest news headlines from a news website:

from selenium import webdriver

driver = webdriver.Chrome(executable_path='/path/to/chromedriver')

try:
    # Open the website
    driver.get("https://example-news-website.com")

    # Find elements representing the headlines
    headlines = driver.find_elements_by_class_name("headline-class")

    # Print each headline
    for headline in headlines:
        print(headline.text)
    
finally:
    driver.quit()

Documentation: WebDriver API

Filling Out Forms Automatically

Filling out web forms can be tedious, but Selenium makes it straightforward:

from selenium import webdriver
from selenium.webdriver.common.keys import Keys

driver = webdriver.Chrome(executable_path='/path/to/chromedriver')

try:
    # Open the form page
    driver.get("https://example.com/form")

    # Fill in different fields
    name_field = driver.find_element_by_id("name")
    email_field = driver.find_element_by_id("email")
    message_field = driver.find_element_by_id("message")

    name_field.send_keys("John Doe")
    email_field.send_keys("johndoe@example.com")
    message_field.send_keys("Hello, this is an automated message.")

    # Submit the form
    message_field.send_keys(Keys.RETURN)
    
finally:
    driver.quit()

Documentation: Form Controls

Automating Website Navigation

Navigating through a website involves actions like clicking links, opening dropdowns, and shifting between pages:

from selenium import webdriver

driver = webdriver.Chrome(executable_path='/path/to/chromedriver')

try:
    # Open the site
    driver.get("https://example.com")

    # Find and click a link to navigate to another page
    link = driver.find_element_by_link_text("Next Page")
    link.click()
    
    # Adding a wait to ensure the new page loads
    driver.implicitly_wait(10)
    
    # Perform another action on the new page
    button = driver.find_element_by_id("start-button")
    button.click()
    
finally:
    driver.quit()

Documentation: Navigation

By leveraging these examples, you can see how Selenium and Python can automate repetitive web tasks, thus saving you valuable time and effort. These code snippets provide a starting point for more complex automations you might want to build.

By exploring the official Selenium documentation for Python, you can uncover a wide range of further functionalities and features to suit your specific automation needs.

Conclusion: Enhancing Productivity with Python and Selenium

In leveraging Selenium for browser automation with Python, you have the potential to significantly enhance your productivity and streamline repetitive tasks. By automating logins, form submissions, data extraction, and even complex multi-page workflows, you can free up valuable time for more strategic work. For instance, a script to automate login to multiple websites daily can look something like this:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys

# Set up the WebDriver
driver = webdriver.Chrome(executable_path='path/to/chromedriver')

# URLs to automate
urls = {
    'Website 1': 'http://example.com/login',
    'Website 2': 'http://anotherexample.com/login',
}

# Credentials
credentials = {
    'Website 1': {'username': 'user1', 'password': 'password1'},
    'Website 2': {'username': 'user2', 'password': 'password2'},
}

# Function to automate login
def automate_login(url, username, password):
    driver.get(url)
    driver.find_element(By.NAME, 'username').send_keys(username)
    driver.find_element(By.NAME, 'password').send_keys(password)
    driver.find_element(By.NAME, 'login').send_keys(Keys.RETURN)

# Loop through websites and perform login
for site, url in urls.items():
    creds = credentials[site]
    automate_login(url, creds['username'], creds['password'])
    print(f"Logged into {site}")

driver.quit()

The webdriver module from Selenium offers a simple interface to handle browser automation. In the example above, we set up a webdriver for Chrome, but Selenium supports various browsers such as Firefox, Edge, Safari, etc. Adjust your WebDriver initialization accordingly.

To handle more sophisticated interactions, Selenium’s support for expected conditions can be a game-changer. Using WebDriverWait alongside ExpectedConditions ensures robust automation that can handle dynamic content efficiently:

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Example of waiting for an element to be clickable before performing an action
wait = WebDriverWait(driver, 10)
element = wait.until(EC.element_to_be_clickable((By.ID, 'submit-button')))
element.click()

By integrating these techniques, your scripts can handle more complex workflows with greater reliability. Also, combining Selenium with other Python libraries like Beautiful Soup for data extraction or pandas for data handling can open new possibilities for comprehensive automation projects.

For password management and more secure credential handling, you might want to consider integrating with keyring or other secrets management tools, further highlighting the flexibility and security offered by Python’s rich ecosystem.

import keyring

# Set and get credentials securely using keyring
keyring.set_password("system", "username", "password")
stored_password = keyring.get_password("system", "username")

Selenium’s extensive documentation and active community make troubleshooting easier and keep you up-to-date with best practices. For further exploration and examples, refer to the official Selenium documentation.

Related Posts