Das deutsche Python-Forum

Hallo Leute,

Ich bin neu hier und komme ursprünglich aus der AutoIt-Welt des Codings. Nun habe ich mich zum ersten Mal mit Python auseinandergesetzt und bin mir noch nicht ganz sicher im Umgang mit dieser Programmiersprache.
Für mein aktuelles Projekt, das ich zuvor in AutoIt fertiggestellt hatte, aber ohnehin umändern muss, habe ich mich entschlossen, es mit Python zu programmieren. Bei meinen ersten Tests habe ich bereits eine GUI und ein Einstellungsfenster erstellt, um den Start des Webdrivers individuell zu gestalten.

Warum mache ich das?
Nun, ich muss Daten von einer firmeneigenen Seite abrufen und möchte dabei möglichst viele Ressourcen sparen.
Unter AutoIt konnte ich nicht alle Optionen des Webdrivers durchtesten.
Daher möchte ich ein Menü schaffen, das alle Eigenschaften und Einstellungen umfasst, um herauszufinden, was benötigt wird und was während der Laufzeit des Programms abgeschaltet werden kann.

Leider werden meine Einstellungen zwar in der SQLite-Datei übernommen, in der die Konfiguration gespeichert wird, aber nicht alle Funktionen/Argumente werden ausgeführt, wenn ich die Argumente auswähle.
Headless- und Inkognito-Modus funktionieren immer, aber z.B. das Nichtladen von Bildern funktioniert nicht. Wenn ich die Einstellungen direkt im Code angebe und starte, funktioniert alles einwandfrei.

Momentan habe ich nur 'Chrome' im Code berücksichtigt, möchte aber gerne, dass es mit allen Browsern funktioniert. Es muss jedoch erst einmal bei einem Browser funktionieren.
Hat jemand vielleicht ähnliche Erfahrungen gemacht oder Ideen, woran das liegen könnte?

Jede Hilfe wäre sehr willkommen!
Vielen Dank im Voraus!

module :

Code: Alles auswählen

pip install selenium webdriver-manager customtkinter

Code: Alles auswählen

(edit: selenium
beautifulsoup4
requests
PyQt5
SQLAlchemy)

Code: Alles auswählen

import os
import sqlite3
from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService
from selenium.webdriver.firefox.service import Service as FirefoxService
from selenium.webdriver.safari.service import Service as SafariService
from selenium.webdriver.edge.service import Service as EdgeService
from webdriver_manager.chrome import ChromeDriverManager
from webdriver_manager.firefox import GeckoDriverManager
from webdriver_manager.microsoft import EdgeChromiumDriverManager
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.firefox.options import Options as FirefoxOptions
from selenium.webdriver.safari.options import Options as SafariOptions
from selenium.webdriver.edge.options import Options as EdgeOptions
import customtkinter as ctk
import tkinter as tk


class WebDriverManager:
    def __init__(self):
        self.settings_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'settings')
        os.makedirs(self.settings_dir, exist_ok=True)
        self.config_path = os.path.join(self.settings_dir, 'config.db')
        self.driver = None
        self.browser = None
        self.detailed_report = False
        self.chrome_options = []
        self.create_config_table()
        self.load_settings()

    def create_config_table(self):
        conn = sqlite3.connect(self.config_path)
        c = conn.cursor()
        c.execute('''CREATE TABLE IF NOT EXISTS webdriver_settings (
                        id INTEGER PRIMARY KEY,
                        browser TEXT,
                        detailed_report BOOLEAN,
                        chrome_options TEXT
                    )''')
        conn.commit()
        conn.close()

    def load_settings(self):
        conn = sqlite3.connect(self.config_path)
        c = conn.cursor()
        c.execute("SELECT * FROM webdriver_settings WHERE id=1")
        row = c.fetchone()
        if row:
            self.browser = row[1]
            self.detailed_report = bool(row[2])
            self.chrome_options = row[3].split(',')
        conn.close()

    def save_settings(self, browser, detailed_report, chrome_options):
        chrome_options_str = ','.join(chrome_options)
        conn = sqlite3.connect(self.config_path)
        c = conn.cursor()
        c.execute('''INSERT OR REPLACE INTO webdriver_settings 
                    (id, browser, detailed_report, chrome_options) 
                    VALUES (?, ?, ?, ?)''',
                  (1, browser, detailed_report, chrome_options_str))
        conn.commit()
        conn.close()

    def start_webdriver(self, browser, chrome_options):
        if self.driver:
            self.driver.quit()

        self.browser = browser
        self.chrome_options = chrome_options

        options = None
        service = None

        print(f"Starting WebDriver with options: {self.chrome_options}")

        if self.browser == "chrome":
            options = ChromeOptions()
            for option in self.chrome_options:
                if '=' in option:
                    key, value = option.split('=', 1)
                    options.add_argument(f"--{key}={value}")
                else:
                    options.add_argument(f"--{option}")
            if 'useAutomationExtension=false' in self.chrome_options:
                options.add_experimental_option('useAutomationExtension', False)
            if 'disable-blink-features=AutomationControlled' in self.chrome_options:
                options.add_argument('--disable-blink-features=AutomationControlled')
            service = ChromeService(ChromeDriverManager().install())

        elif self.browser == "firefox":
            options = FirefoxOptions()
            # Fügen Sie hier Ihre Firefox-Optionen hinzu
            service = FirefoxService(GeckoDriverManager().install())

        elif self.browser == "safari":
            options = SafariOptions()
            # Fügen Sie hier Ihre Safari-Optionen hinzu
            service = SafariService()

        elif self.browser == "edge":
            options = EdgeOptions()
            options.use_chromium = True
            # Fügen Sie hier Ihre Edge-Optionen hinzu
            service = EdgeService(EdgeChromiumDriverManager().install())

        if options and service:
            if self.browser == "chrome":
                self.driver = webdriver.Chrome(service=service, options=options)
            elif self.browser == "firefox":
                self.driver = webdriver.Firefox(service=service, options=options)
            elif self.browser == "safari":
                self.driver = webdriver.Safari(service=service, options=options)
            elif self.browser == "edge":
                self.driver = webdriver.Edge(service=service, options=options)

        if self.detailed_report:
            self.enable_detailed_logging()

    def enable_detailed_logging(self):
        # Implement logging setup here
        pass


class WebDriverSettings(tk.Toplevel):
    def __init__(self, parent):
        super().__init__(parent)
        self.title("WebDriver Einstellungen")
        self.geometry("700x900")
        self.create_widgets()
        self.webd_func = WebDriverManager()
        self.load_settings()

    def create_widgets(self):
        options_frame = ctk.CTkFrame(self)
        options_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

        self.browser_var = tk.StringVar(value="chrome")
        ctk.CTkLabel(options_frame, text="Browser:").pack(anchor=tk.W)
        ctk.CTkRadioButton(options_frame, text="Chrome", variable=self.browser_var, value="chrome").pack(anchor=tk.W)
        ctk.CTkRadioButton(options_frame, text="Firefox", variable=self.browser_var, value="firefox").pack(anchor=tk.W)
        ctk.CTkRadioButton(options_frame, text="Safari", variable=self.browser_var, value="safari").pack(anchor=tk.W)
        ctk.CTkRadioButton(options_frame, text="Edge", variable=self.browser_var, value="edge").pack(anchor=tk.W)

        self.detailed_report_var = tk.BooleanVar(value=False)
        ctk.CTkLabel(options_frame, text="Ausführlicher Bericht:").pack(anchor=tk.W)
        ctk.CTkCheckBox(options_frame, text="Erstellen", variable=self.detailed_report_var).pack(anchor=tk.W)

        self.chrome_options_frame = ctk.CTkFrame(options_frame)
        self.chrome_options_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        ctk.CTkLabel(self.chrome_options_frame, text="Chrome Optionen:").pack(anchor=tk.W)

        chrome_options = [
            ("Kopflose Ausführung", "headless", "Führt den Browser im Kopflose Modus aus."),
            ("Keine Sandbox", "no_sandbox", "Deaktiviert die Sandbox-Sicherheitsfunktion."),
            ("Deaktivieren der Verwendung von /dev/shm", "disable_dev_shm_usage", "Verhindert die Nutzung von /dev/shm für mehr Stabilität."),
            ("Deaktivieren von Erweiterungen", "disable_extensions", "Deaktiviert alle installierten Erweiterungen."),
            ("Inkognito-Modus", "incognito", "Startet den Browser im Inkognito-Modus."),
            ("Maximiertes Fenster starten", "start_maximized", "Startet den Browser im maximierten Modus."),
            ("Deaktivieren der Infobars", "disable_infobars", "Deaktiviert Infobars."),
            ("Deaktivieren des Popup-Blockers", "disable_popup_blocking", "Deaktiviert den Popup-Blocker."),
            ("Deaktivieren der Web-Sicherheit", "disable_web_security", "Deaktiviert die Web-Sicherheitsfunktionen."),
            ("Sprache auf Deutsch setzen", "lang=de", "Setzt die Sprache des Browsers auf Deutsch."),
            ("Deaktivieren der Blink-Features für Automatisierungskontrolle", "disable_blink_features=AutomationControlled", "Deaktiviert die Blink-Features."),
            ("Deaktivieren der JavaScript", "disable_javascript", "Deaktiviert JavaScript."),
            ("Deaktivieren der Plugins", "disable_plugins", "Deaktiviert Plugins."),
            ("Deaktivieren der PDF-Material-UI", "disable_pdf_material_ui", "Deaktiviert die PDF-Material-UI."),
            ("Deaktivieren des Hintergrund-Timer-Drosselung", "disable_background_timer_throttling", "Deaktiviert die Drosselung von Hintergrund-Timern."),
            ("Deaktivieren der Hintergrund-Fenster", "disable_backgrounding_occluded_windows", "Deaktiviert Hintergrund-Fenster."),
            ("Deaktivieren des Renderer-Hintergrundes", "disable_renderer_backgrounding", "Deaktiviert den Hintergrund des Renderers."),
            ("Deaktivieren des Hang-Monitors", "disable_hang_monitor", "Deaktiviert den Hang-Monitor."),
            ("Deaktivieren der Synchronisation", "disable_sync", "Deaktiviert die Synchronisation."),
            ("Deaktivieren der Übersetzungsfunktion", "disable_translate", "Deaktiviert die automatische Übersetzung."),
            ("Nur Metriken aufzeichnen", "metrics_recording_only", "Zeichnet nur Metriken auf."),
            ("Automatische Safe-Browsing-Updates deaktivieren", "safebrowsing_disable_auto_update", "Deaktiviert automatische Safe-Browsing-Updates."),
            ("Zertifikatfehler ignorieren", "ignore_certificate_errors", "Ignoriert alle SSL-Zertifikatfehler."),
            ("Erlaube unsicheren localhost", "allow_insecure_localhost", "Ignoriert unsichere Verbindungen zu localhost."),
            ("Erlaube Loopback in Peer-Verbindung", "allow_loopback_in_peer_connection", "Erlaubt die Verwendung von Loopback in Peer-Verbindungen."),
            ("Deaktiviere Blink-Bilder", "blink_settings=imagesEnabled=false", "Deaktiviert das Laden von Bildern."),
            ("Automatisierungsinformationen deaktivieren", "useAutomationExtension=false", "Deaktiviert die Anzeige von Automatisierungsinformationen."),
        ]

        self.chrome_vars = {}
        for text, value, tooltip in chrome_options:
            var = tk.BooleanVar(value=False)
            self.chrome_vars[value] = var
            self.create_checkbox(self.chrome_options_frame, text, var, tooltip)

        save_button = ctk.CTkButton(self, text="Speichern", command=self.save_settings)
        save_button.pack(pady=10)

    def create_checkbox(self, frame, text, var, tooltip):
        checkbox = ctk.CTkCheckBox(frame, text=text, variable=var)
        checkbox.pack(anchor=tk.W)
        checkbox.bind("<Enter>", lambda event, tooltip=tooltip: self.show_tooltip(event, tooltip))
        checkbox.bind("<Leave>", self.hide_tooltip)

    def show_tooltip(self, event, text):
        x = event.widget.winfo_rootx() + 20
        y = event.widget.winfo_rooty() + 20
        self.tooltip = tk.Toplevel(self)
        self.tooltip.wm_overrideredirect(True)
        self.tooltip.wm_geometry(f"+{x}+{y}")
        label = tk.Label(self.tooltip, text=text, background="yellow", relief="solid", borderwidth=1, padx=1, pady=1)
        label.pack()

    def hide_tooltip(self, event):
        if self.tooltip:
            self.tooltip.destroy()
        self.tooltip = None

    def load_settings(self):
        self.webd_func.load_settings()

    def save_settings(self):
        browser = self.browser_var.get()
        detailed_report = self.detailed_report_var.get()
        chrome_options = [key for key, var in self.chrome_vars.items() if var.get()]
        self.webd_func.save_settings(browser, detailed_report, chrome_options)
        self.webd_func.start_webdriver(browser, chrome_options)


if __name__ == "__main__":
    root = tk.Tk()
    root.withdraw()  # Versteckt das Hauptfenster
    app = WebDriverSettings(root)
    app.mainloop()

Edit :

Nochmal kurz zurückmeldung : ich wollte eigentlich den code kleiner halten deshalb ist das nicht der ganze ich habe grad den code in einer neune Instanz getestet und musste feststellen das es bei euch nicht funktionieren wird, ich werde den code nochmal anpassen und durchtesten bitte lasst mir zeit wie gesagt ich bin neu in python.

Anmerkungen zum Quelltext: Das Hauptprogramm sollte in einer Funktion verschwinden, damit `root` und `app` keine global erreichbaren Namen mehr sind.

Warum wird das Hauptfenster versteckt und nicht benutzt?

In neuem Code sollte man nicht mehr die Funktionen aus `os.path` & Co verwenden, sondern das `pathlib`-Modul.

`WebDriverManager` ist komisch. `load_settings()` setzt Attribute während `save_settings()` nicht die Attribute speichert die bei `load_settings()` gesetzt werden, sondern die Werte die gespeichert werden als Argumente bekommt.

Es wäre auch sinnvoller so ein Objekt erstellen zu können ohne dass das Verzeichnisse erstellt und eine Verbindung zu einer Datenbank aufbaut, und das die notwendigen Daten als Argumente entgegen nimmt. Wenn man so ein Objekt aus Werten aus einer Datenbank erstellen möchte, kann man das in einer Klassenmethode machen.

Wobei die relationale Datenbank für *eine* Tabelle mit *einem* Datensatz keinen Sinn macht. Da würde man besser eine Konfigurationsdatei in einem Standardformat wie INI oder JSON verwenden.

Das gilt auch für den Inhalt von der Datenbankspalte für die Optionen. Da eine Zeichenkette an "," zusammen basteln und später wieder zu trennen ist nicht robust wenn da mal irgendwann Optionen drin gespeichert werden müssen wo das "," Bestandteil eines Wertes ist. Auch hier würde man besser ein Standardformat verwenden was kein Problem mit Trennzeichen in Werten hat. CSV oder JSON beispielsweise. Für all diese genannten Formate gibt es was in der Python-Standardbibliothek.

Namen sollten keine kryptischen Abkürzungen enthalten, oder gar nur daraus bestehen. Wenn man `connection` oder `cursor` meint, sollte man nicht `conn` oder `c` schreiben.

`start_webdriver()` bekommt dann auch noch mal den Browser und die Optionen als Argumente statt die Attribute zu verwenden in denen diese Information doch schon stehen sollte‽

Die ``if``/``elif``-Konstrukte die den Browser gegen bekannte Browsernamen prüfen, sollten einen ``else``-Zweig am Ende besitzen der eine Ausnahme auslöst wenn der Wert nicht behandelt wurde.

Das ``if '=' in option:``-Konstrukt macht keinen Sinn. Da kommt am Ende egal ob der ``if``- oder der ``else``-Zweig ausgeführt wird, das gleiche Ergebnis bei heraus.

Die `WebDriverSettings`-Klasse habe ich mir nicht näher angeschaut.

Warum benutzt Du das Hauptfenster gar nicht?
Die Größe des Fensters ergibt sich aus dem Inhalt, die setzt man nicht explizit.
Die Settings werden bei load_settings gar nicht gesetzt.
Statt lambda benutzt man hier partial.
Warum heißt das WebDriverManager webd_func?
Warum werden bei start_webdriver nochmal die selben Argumente übergeben, die schon in den Settings stehen?
Ich würde die ganze Settingsverwaltung auf json umstellen und aus WebDriverManager herausnehmen.
Settings werden üblicherweise relativ zu Home gespeichert und nicht zu der py-Datei, die ja hoffentlich an einem Ort liegt, wo man üblicherweise gar keine Schreibrechte hat.

Code: Alles auswählen

import json
from functools import partial
from pathlib import Path
import tkinter as tk
import customtkinter as ctk

from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService
from selenium.webdriver.firefox.service import Service as FirefoxService
from selenium.webdriver.safari.service import Service as SafariService
from selenium.webdriver.edge.service import Service as EdgeService
from webdriver_manager.chrome import ChromeDriverManager
from webdriver_manager.firefox import GeckoDriverManager
from webdriver_manager.microsoft import EdgeChromiumDriverManager
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.firefox.options import Options as FirefoxOptions
from selenium.webdriver.safari.options import Options as SafariOptions
from selenium.webdriver.edge.options import Options as EdgeOptions

SETTINGS = Path.home() / ".webdriver.json"

BROWSERS = [
    "Chrome",
    "Firefox",
    "Safari",
    "Edge",
]

CHROME_OPTIONS = [
    ("Kopflose Ausführung", "headless", "Führt den Browser im Kopflose Modus aus."),
    ("Keine Sandbox", "no_sandbox", "Deaktiviert die Sandbox-Sicherheitsfunktion."),
    ("Deaktivieren der Verwendung von /dev/shm", "disable_dev_shm_usage", "Verhindert die Nutzung von /dev/shm für mehr Stabilität."),
    ("Deaktivieren von Erweiterungen", "disable_extensions", "Deaktiviert alle installierten Erweiterungen."),
    ("Inkognito-Modus", "incognito", "Startet den Browser im Inkognito-Modus."),
    ("Maximiertes Fenster starten", "start_maximized", "Startet den Browser im maximierten Modus."),
    ("Deaktivieren der Infobars", "disable_infobars", "Deaktiviert Infobars."),
    ("Deaktivieren des Popup-Blockers", "disable_popup_blocking", "Deaktiviert den Popup-Blocker."),
    ("Deaktivieren der Web-Sicherheit", "disable_web_security", "Deaktiviert die Web-Sicherheitsfunktionen."),
    ("Sprache auf Deutsch setzen", "lang=de", "Setzt die Sprache des Browsers auf Deutsch."),
    ("Deaktivieren der Blink-Features für Automatisierungskontrolle", "disable_blink_features=AutomationControlled", "Deaktiviert die Blink-Features."),
    ("Deaktivieren der JavaScript", "disable_javascript", "Deaktiviert JavaScript."),
    ("Deaktivieren der Plugins", "disable_plugins", "Deaktiviert Plugins."),
    ("Deaktivieren der PDF-Material-UI", "disable_pdf_material_ui", "Deaktiviert die PDF-Material-UI."),
    ("Deaktivieren des Hintergrund-Timer-Drosselung", "disable_background_timer_throttling", "Deaktiviert die Drosselung von Hintergrund-Timern."),
    ("Deaktivieren der Hintergrund-Fenster", "disable_backgrounding_occluded_windows", "Deaktiviert Hintergrund-Fenster."),
    ("Deaktivieren des Renderer-Hintergrundes", "disable_renderer_backgrounding", "Deaktiviert den Hintergrund des Renderers."),
    ("Deaktivieren des Hang-Monitors", "disable_hang_monitor", "Deaktiviert den Hang-Monitor."),
    ("Deaktivieren der Synchronisation", "disable_sync", "Deaktiviert die Synchronisation."),
    ("Deaktivieren der Übersetzungsfunktion", "disable_translate", "Deaktiviert die automatische Übersetzung."),
    ("Nur Metriken aufzeichnen", "metrics_recording_only", "Zeichnet nur Metriken auf."),
    ("Automatische Safe-Browsing-Updates deaktivieren", "safebrowsing_disable_auto_update", "Deaktiviert automatische Safe-Browsing-Updates."),
    ("Zertifikatfehler ignorieren", "ignore_certificate_errors", "Ignoriert alle SSL-Zertifikatfehler."),
    ("Erlaube unsicheren localhost", "allow_insecure_localhost", "Ignoriert unsichere Verbindungen zu localhost."),
    ("Erlaube Loopback in Peer-Verbindung", "allow_loopback_in_peer_connection", "Erlaubt die Verwendung von Loopback in Peer-Verbindungen."),
    ("Deaktiviere Blink-Bilder", "blink_settings=imagesEnabled=false", "Deaktiviert das Laden von Bildern."),
    ("Automatisierungsinformationen deaktivieren", "useAutomationExtension=false", "Deaktiviert die Anzeige von Automatisierungsinformationen."),
]

class WebDriverSettings(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("WebDriver Einstellungen")
        self.create_widgets()
        self.load_settings()

    def create_widgets(self):
        options_frame = ctk.CTkFrame(self)
        options_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

        self.browser_var = tk.StringVar(self, value="chrome")
        ctk.CTkLabel(options_frame, text="Browser:").pack(anchor=tk.W)
        for browser in BROWSERS:
            ctk.CTkRadioButton(options_frame, text=browser,
                variable=self.browser_var, value=browser.lower()
            ).pack(anchor=tk.W)

        self.detailed_report_var = tk.BooleanVar(self, value=False)
        ctk.CTkLabel(options_frame, text="Ausführlicher Bericht:").pack(anchor=tk.W)
        ctk.CTkCheckBox(options_frame, text="Erstellen", variable=self.detailed_report_var).pack(anchor=tk.W)

        self.chrome_options_frame = ctk.CTkFrame(options_frame)
        self.chrome_options_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        ctk.CTkLabel(self.chrome_options_frame, text="Chrome Optionen:").pack(anchor=tk.W)

        self.chrome_vars = {}
        for text, value, tooltip in CHROME_OPTIONS:
            var = tk.BooleanVar(self, value=False)
            self.chrome_vars[value] = var
            self.create_checkbox(self.chrome_options_frame, text, var, tooltip)

        save_button = ctk.CTkButton(self, text="Speichern", command=self.save_settings)
        save_button.pack(pady=10)

    def create_checkbox(self, frame, text, var, tooltip):
        checkbox = ctk.CTkCheckBox(frame, text=text, variable=var)
        checkbox.pack(anchor=tk.W)
        checkbox.bind("<Enter>", partial(self.show_tooltip, text=tooltip))
        checkbox.bind("<Leave>", self.hide_tooltip)

    def show_tooltip(self, event, text):
        x = event.widget.winfo_rootx() + 20
        y = event.widget.winfo_rooty() + 20
        self.tooltip = tk.Toplevel(self)
        self.tooltip.wm_overrideredirect(True)
        self.tooltip.wm_geometry(f"+{x}+{y}")
        label = tk.Label(self.tooltip, text=text, background="yellow", relief="solid", borderwidth=1, padx=1, pady=1)
        label.pack()

    def hide_tooltip(self, event):
        if self.tooltip:
            self.tooltip.destroy()
        self.tooltip = None

    def load_settings(self):
        if SETTINGS.exists():
            settings = json.loads(SETTINGS.read_text())
            self.browser_var.set(settings['browser'])
            self.detailed_report_var.set(settings['detailed_report'])
            for key, var in self.chrome_vars.items():
                var.set(key in settings['options'])

    def save_settings(self):
        browser = self.browser_var.get()
        detailed_report = self.detailed_report_var.get()
        chrome_options = [key for key, var in self.chrome_vars.items() if var.get()]
        SETTINGS.write_text(json.dumps({
           'browser': browser,
           'detailed_report': detailed_report,
           'options': chrome_options, 
        }))
        webdriver = WebDriverManager(browser, detailed_report, chrome_options)
        webdriver.start_webdriver()

class WebDriverManager:
    def __init__(self, browser, detailed_report, chrome_options):
        self.driver = None
        self.browser = browser
        self.detailed_report = detailed_report
        self.chrome_options = chrome_options

    def start_webdriver(self):
        if self.driver:
            self.driver.quit()

        print(f"Starting WebDriver with options: {self.chrome_options}")

        if self.browser == "chrome":
            options = ChromeOptions()
            for option in self.chrome_options:
                if '=' in option:
                    key, value = option.split('=', 1)
                    options.add_argument(f"--{key}={value}")
                else:
                    options.add_argument(f"--{option}")
            if 'useAutomationExtension=false' in self.chrome_options:
                options.add_experimental_option('useAutomationExtension', False)
            if 'disable-blink-features=AutomationControlled' in self.chrome_options:
                options.add_argument('--disable-blink-features=AutomationControlled')
            service = ChromeService(ChromeDriverManager().install())
            driver_class = webdriver.Chrome
        elif self.browser == "firefox":
            options = FirefoxOptions()
            # Fügen Sie hier Ihre Firefox-Optionen hinzu
            service = FirefoxService(GeckoDriverManager().install())
            driver_class = webdriver.Firefox
        elif self.browser == "safari":
            options = SafariOptions()
            # Fügen Sie hier Ihre Safari-Optionen hinzu
            service = SafariService()
            driver_class = webdriver.Safari
        elif self.browser == "edge":
            options = EdgeOptions()
            options.use_chromium = True
            # Fügen Sie hier Ihre Edge-Optionen hinzu
            service = EdgeService(EdgeChromiumDriverManager().install())
            driver_class = webdriver.Edge
        else:
            print("Browser unbekannt.")
            return

        self.driver = driver_class(service=service, options=options)

        if self.detailed_report:
            self.enable_detailed_logging()

    def enable_detailed_logging(self):
        # Implement logging setup here
        pass


def main():
    root = WebDriverSettings()
    root.mainloop()

if __name__ == "__main__":
    main()

Das deutsche Python-Forum

Selinium Webdriver

Selinium Webdriver

Re: Selinium Webdriver

Re: Selinium Webdriver

Re: Selinium Webdriver