Für jede Suche wird jetzt ein Tab geöffnet anstatt

für jede Suche einen Browser.
Dazu wird der Webdriver dazu gebracht ein neuen Tab zu öffnen
und die Suchanfrage für die Webseite auf den neuen Tab
zu wechseln.

einkauf_suche.py

@@ -10,6 +10,8 @@ from bs4 import BeautifulSoup
 import sys
 import concurrent.futures
 
+BLANK_PAGE_URL = ""
+
 class SearchThread(QThread):
     search_finished = pyqtSignal()
 
@@ -18,156 +20,149 @@ class SearchThread(QThread):
         self.selected_webpages = selected_webpages
         self.search_term = search_term
         self.error_message = None
-        self.drivers = {}
+        self.driver = webdriver.Edge()
 
     def run(self):
-    
+        try:
-            with ThreadPoolExecutor() as executor:
+            for webseite in self.selected_webpages:
-                futures = {executor.submit(self.start_search_on_webseite, webseite): webseite for webseite in self.selected_webpages}
+                self.start_search_on_webseite(webseite)
-                    
+        except Exception as e:
-                for future in concurrent.futures.as_completed(futures):
+            self.error_message = f"Fehler bei der Suche: {e}"
-                    try:
+        finally:
-                        future.result()  # Warte auf das Ende der Suche
+            self.search_finished.emit()
-                    except Exception as e:
-                        self.error_message = f"Fehler bei der Suche: {e}"
 
-    def initialize_driver(self, webseite):
-        self.drivers[webseite] = webdriver.Edge()
 
     def start_search_on_webseite(self, webseite):
         try:
-            self.initialize_driver(webseite)
+            self.driver.execute_script(f"window.open('{BLANK_PAGE_URL}', '_blank');")
+
+            self.driver.switch_to.window(self.driver.window_handles[-1])
 
             if webseite == "Reichelt":
-                self.suche_auf_reichelt(webseite)
+                self.suche_auf_reichelt()
             elif webseite == "Conrad":
-                self.suche_auf_conrad(webseite)
+                self.suche_auf_conrad()
             elif webseite == "Kosatec":
-                self.suche_auf_kosatec(webseite)
+                self.suche_auf_kosatec()
             elif webseite == "Hornbach": 
-                self.suche_auf_hornbach(webseite)
+                self.suche_auf_hornbach()
             elif webseite =="Contorion":
-                self.suche_auf_contorion(webseite)
+                self.suche_auf_contorion()
             elif webseite == "Gastro Teile Shop":
-                self.suche_auf_gastroteileshop(webseite)
+                self.suche_auf_gastroteileshop()
             elif webseite == "TiroLED":
-                self.suche_auf_tiroled(webseite)
+                self.suche_auf_tiroled()
             elif webseite == "Megabad":
-                self.suche_auf_megabad(webseite)
+                self.suche_auf_megabad()
             elif webseite == "IPS":
-                self.suche_auf_ips_shop(webseite)
+                self.suche_auf_ips_shop()
             elif webseite == "Brewes":
-                self.suche_auf_brewes(webseite)
+                self.suche_auf_brewes()
             elif webseite == "Delker":
-                self.suche_auf_delker(webseite)
+                self.suche_auf_delker()
             elif webseite == "Knauss":
-                self.suche_auf_knauss(webseite)
+                self.suche_auf_knauss()
             elif webseite == "Schildershop24":
-                self.suche_auf_schildershop24(webseite)
+                self.suche_auf_schildershop24()
             elif webseite == "Häfele":
-                self.suche_auf_haefele(webseite)
+                self.suche_auf_haefele()
             elif webseite == "Esmeyer":
-                self.suche_auf_esmeyer(webseite)
+                self.suche_auf_esmeyer()
             elif webseite == "Papstar":
-                 self.suche_auf_papstar(webseite)
+                 self.suche_auf_papstar()
             elif webseite == "Lusini":
-                self.suche_auf_lusini(webseite)
+                self.suche_auf_lusini()
             elif webseite == "Hygi":
-                self.suche_auf_hygi(webseite)
+                self.suche_auf_hygi()
             elif webseite == "Schafferer":
-                self.suche_auf_schafferer(webseite)
+                self.suche_auf_schafferer()
             elif webseite == "Gastronomie Kaufhaus":
-                self.suche_auf_gastronomie_kaufhaus(webseite)
+                self.suche_auf_gastronomie_kaufhaus()
             elif webseite == "Böttcher":
-                self.suche_auf_boettcher(webseite)
+                self.suche_auf_boettcher()
             elif webseite == "Büroshop24":
-                self.suche_auf_bueroshop24(webseite)
+                self.suche_auf_bueroshop24()
     
         except Exception as e:
             print(f"Fehler bei der Suche auf {webseite}: {e}")
 
-    def suche_auf_haefele(self,webseite):
+    def suche_auf_haefele(self):
 
-        driver = self.drivers[webseite]
+        
         # URL für die Suche generieren
         search_url = 'https://www.haefele.de/'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "inputSearchTerm")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "inputSearchTerm")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.ID, "inputSearchTerm")
+        search_box = self.driver.find_element(By.ID, "inputSearchTerm")
         search_box.clear()  
         search_box.send_keys(self.search_term)
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_brewes(self, webseite):
+    def suche_auf_brewes(self, ):
-        driver = self.drivers[webseite]
+        
 
         # URL für die Suche generieren
         search_url = 'https://www.brewes.de/catalogsearch/result?q='
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "search")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.ID, "search")
+        search_box = self.driver.find_element(By.ID, "search")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_conrad(self, webseite):
+    def suche_auf_conrad(self):
         # WebDriver initialisieren
-        driver = self.drivers[webseite]
+        
-
         # Such-URL generieren
         search_url = f'https://www.conrad.de/search.html?search={self.search_term}'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "header-search")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "header-search")))
 
         # Suchbegriff eingeben
-        search_box = driver.find_element(By.ID, "header-search")
+        search_box = self.driver.find_element(By.ID, "header-search")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_contorion(self, webseite):
+    def suche_auf_contorion(self):
-        driver = self.drivers[webseite]
+        
         # Such-URL generieren
         search_url = f'https://www.contorion.de/suche?q={self.search_term}'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))
 
         # Suchbegriff eingeben
-        search_box = driver.find_element(By.ID, "search-input")
+        search_box = self.driver.find_element(By.ID, "search-input")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_reichelt(self, webseite):
+    def suche_auf_reichelt(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
-
-    
             # Such-URL generieren
         search_url = f'https://www.reichelt.de/index.html?ACTION=446&LA=446&nbc=1&SEARCH={self.search_term}'
 
             # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 60).until(EC.presence_of_element_located((By.ID, "searchbutton")))
+        WebDriverWait(self.driver, 60).until(EC.presence_of_element_located((By.ID, "searchbutton")))
 
             # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.ID, "quicksearch_new")
+        search_box = self.driver.find_element(By.ID, "quicksearch_new")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
@@ -175,315 +170,274 @@ class SearchThread(QThread):
         search_button = self.driver.find_element(By.ID, "searchbutton")
         search_button.click()
 
-    def suche_auf_kosatec(self, webseite):
+    def suche_auf_kosatec(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
 
         # Such-URL generieren
         search_url = f'https://www.kosatec.de/suche?query={self.search_term}'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, "input[name='search']")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, "input[name='search']")))
 
         # Suchbegriff eingeben
-        search_box = driver.find_element(By.CSS_SELECTOR, "input[name='search']")
+        search_box = self.driver.find_element(By.CSS_SELECTOR, "input[name='search']")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_hornbach(self,webseite):
+    def suche_auf_hornbach(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
 
         # URL für die Suche generieren
         search_url = 'https://www.hornbach.de/s/'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "global_search")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "global_search")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.NAME, "global_search")
+        search_box = self.driver.find_element(By.NAME, "global_search")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
         search_box.send_keys(Keys.RETURN)
         
-    def suche_auf_gastroteileshop(self, webseite):
+    def suche_auf_gastroteileshop(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
 
         # URL für die Suche generieren
         search_url = f'https://www.gastroteileshop.de/?s={self.search_term}'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
 
         # Warten, bis das Suchfeld sichtbar ist
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "search-input")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "search-input")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.CLASS_NAME, "search-input")
+        search_box = self.driver.find_element(By.CLASS_NAME, "search-input")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_tiroled(self, webseite):
+    def suche_auf_tiroled(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
-
         # URL für die Suche generieren
         search_url = 'https://www.tiroled.de/de/search'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.NAME, "search")
+        search_box = self.driver.find_element(By.NAME, "search")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_megabad(self, webseite):
+    def suche_auf_megabad(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
-
         # URL für die Suche generieren
         search_url = 'https://www.megabad.com/'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "search-bar-input")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-bar-input")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.ID, "search-bar-input")
+        search_box = self.driver.find_element(By.ID, "search-bar-input")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_ips_shop(self, webseite):
+    def suche_auf_ips_shop(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
 
         # URL für die Suche generieren
         search_url = 'https://www.ips-kts.com/de/suche?query='
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.NAME, "query")
+        search_box = self.driver.find_element(By.NAME, "query")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_delker(self, webseite):
+    def suche_auf_delker(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
 
         # URL für die Suche generieren
         search_url = 'https://www.delker2business.com/nw2017/'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))
 
         # Suchbegriff eingeben und Suche starten 
-        search_box = driver.find_element(By.NAME, "query")
+        search_box = self.driver.find_element(By.NAME, "query")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken, um die Suche zu starten
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_knauss(self, webseite):
+    def suche_auf_knauss(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
-
         # URL für die Suche generieren
         search_url = 'https://www.knauss.info/'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "sSearch")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "sSearch")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.NAME, "sSearch")
+        search_box = self.driver.find_element(By.NAME, "sSearch")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken, um die Suche zu starten
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_schildershop24(self, webseite):
+    def suche_auf_schildershop24(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
-
         # URL für die Suche generieren
         search_url = 'https://www.schildershop24.de/'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "search-query-stichwort_neu")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-query-stichwort_neu")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.ID, "search-query-stichwort_neu")
+        search_box = self.driver.find_element(By.ID, "search-query-stichwort_neu")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken, um die Suche zu starten
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_esmeyer(self, webseite):
+    def suche_auf_esmeyer(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
-
         # URL für die Suche generieren
         search_url = 'https://www.esmeyer-shop.de/'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.NAME, "search")
+        search_box = self.driver.find_element(By.NAME, "search")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken, um die Suche zu starten
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_papstar(self, webseite):
+    def suche_auf_papstar(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
-
         # URL für die Suche generieren
         search_url = 'https://www.papstar-shop.de/'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "search")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.ID, "search")
+        search_box = self.driver.find_element(By.ID, "search")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken, um die Suche zu starten
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_lusini(self, webseite):
+    def suche_auf_lusini(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
 
         # URL für die Suche generieren
         search_url = 'https://www.lusini.de/'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.ID, "search-input")
+        search_box = self.driver.find_element(By.ID, "search-input")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken, um die Suche zu starten
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_hygi(self, webseite):
+    def suche_auf_hygi(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
-
         # URL für die Suche generieren
         search_url = 'https://www.hygi.de/'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "qbox")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "qbox")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.ID, "qbox")
+        search_box = self.driver.find_element(By.ID, "qbox")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken, um die Suche zu starten
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_schafferer(self, webseite):
+    def suche_auf_schafferer(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
 
         # URL für die Suche generieren
         search_url = 'https://www.schafferer.de/gastro/'
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "quicksearch-input")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "quicksearch-input")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.ID, "quicksearch-input")
+        search_box = self.driver.find_element(By.ID, "quicksearch-input")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken, um die Suche zu starten
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_gastronomie_kaufhaus(self, webseite):
+    def suche_auf_gastronomie_kaufhaus(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
 
         # URL für die Suche generieren
         search_url = 'https://www.gastronomie-kaufhaus.de/' 
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "searchParam")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "searchParam")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.ID, "searchParam")
+        search_box = self.driver.find_element(By.ID, "searchParam")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken, um die Suche zu starten (falls notwendig)
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_boettcher(self, webseite):
+    def suche_auf_boettcher(self):
-    # WebDriver initialisieren
-        driver = self.drivers[webseite]
 
         # URL für die Suche generieren
         search_url = 'https://www.bueromarkt-ag.de/'  # Bitte die tatsächliche URL einsetzen
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "autocomplete-0-input")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "autocomplete-0-input")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.ID, "autocomplete-0-input")
+        search_box = self.driver.find_element(By.ID, "autocomplete-0-input")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
         # Enter-Taste drücken, um die Suche zu starten (falls notwendig)
         search_box.send_keys(Keys.RETURN)
 
-    def suche_auf_bueroshop24(self, webseite):
+    def suche_auf_bueroshop24(self):
-        # WebDriver initialisieren
-        driver = self.drivers[webseite]
 
         # URL für die Suche generieren
         search_url = 'https://www.bueroshop24.de/' 
 
         # Webseite aufrufen und auf das vollständige Laden warten
-        driver.get(search_url)
+        self.driver.get(search_url)
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "searchTerm")))
+        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "searchTerm")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = driver.find_element(By.ID, "searchTerm")
+        search_box = self.driver.find_element(By.ID, "searchTerm")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)