Threads wurden angepasst.

Der Webdriver wird anders initialisiert so dass mehrere diriver
instanzen geöffnet werden.
Code wurde angepasst um doppelten Codes in funktionen zu packen und
sie dann nur aufrufen zu müssen.

einkauf_suche.py

@@ -8,6 +8,7 @@ from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
 from bs4 import BeautifulSoup
 import sys
+import concurrent.futures
 
 class SearchThread(QThread):
     search_finished = pyqtSignal()
@@ -17,154 +18,156 @@ class SearchThread(QThread):
         self.selected_webpages = selected_webpages
         self.search_term = search_term
         self.error_message = None
+        self.drivers = {}
 
     def run(self):
-        try:
+    
-            
-
             with ThreadPoolExecutor() as executor:
-                futures = []
+                futures = {executor.submit(self.start_search_on_webseite, webseite): webseite for webseite in self.selected_webpages}
-
-                
-
-                for webseite in self.selected_webpages:
-                    # Fügen hier andere Suchfunktionen hinzu
-                    # WebDriver initialisieren
-                    self.driver = webdriver.Edge()
                     
-                    if webseite == "Reichelt":
+                for future in concurrent.futures.as_completed(futures):
-                        futures.append(executor.submit(self.suche_auf_reichelt))
+                    try:
-                    elif webseite == "Conrad":
+                        future.result()  # Warte auf das Ende der Suche
-                        futures.append(executor.submit(self.suche_auf_conrad))
+                    except Exception as e:
-                    elif webseite == "Kosatec":
+                        self.error_message = f"Fehler bei der Suche: {e}"
-                        futures.append(executor.submit(self.suche_auf_kosatec))
-                    elif webseite == "Hornbach": 
-                        futures.append(executor.submit(self.suche_auf_hornbach))
-                    elif webseite =="Contorion":
-                        futures.append(executor.submit(self.suche_auf_contorion))
-                    elif webseite == "Gastro Teile Shop":
-                        futures.append(executor.submit(self.suche_auf_gastroteileshop))
-                    elif webseite == "TiroLED":
-                        futures.append(executor.submit(self.suche_auf_tiroled))
-                    elif webseite == "Megabad":
-                        futures.append(executor.submit(self.suche_auf_megabad))
-                    elif webseite == "IPS":
-                        futures.append(executor.submit(self.suche_auf_ips_shop, ))
-                    elif webseite == "Brewes":
-                        futures.append(executor.submit(self.suche_auf_brewes))
-                    elif webseite == "Delker":
-                        futures.appen(executor.submit(self.suche_auf_delker))
-                    elif webseite == "Knauss":
-                        futures.append(executor.submit(self.suche_auf_knauss))
-                    elif webseite == "Schildershop24":
-                        futures.append(executor.submit(self.suche_auf_schildershop24))
-                    elif webseite == "Häfele":
-                        futures.append(executor.submit(self.suche_auf_haefele))
-                    elif webseite == "Esmeyer":
-                        futures.append(executor.submit(self.suche_auf_esmeyer))
-                    elif webseite == "Papstar":
-                        futures.append(executor.submit(self.suche_auf_papstar))
-                    elif webseite == "Lusini":
-                        futures.append(executor.submit(self.suche_auf_lusini))
-                    elif webseite == "Hygi":
-                        futures.append(executor.submit(self.suche_auf_hygi))
-                    elif webseite == "Schafferer":
-                        futures.append(executor.submit(self.suche_auf_schafferer))
-                    elif webseite == "Gastronomie Kaufhaus":
-                        futures.append(executor.submit(self.suche_auf_gastronomie_kaufhaus))
-                    elif webseite == "Böttcher":
-                        futures.append(executor.submit(self.suche_auf_boettcher))
-                    elif webseite == "Büroshop24":
-                        futures.append(executor.submit(self.suche_auf_bueroshop24))
 
-                for future in futures:
+    def initialize_driver(self, webseite):
-                    future.result()  # Warte auf das Ende der Suche
+        self.drivers[webseite] = webdriver.Edge()
 
-            self.search_finished.emit()
+    def start_search_on_webseite(self, webseite):
+        try:
+            self.initialize_driver(webseite)
+
+            if webseite == "Reichelt":
+                self.suche_auf_reichelt(webseite)
+            elif webseite == "Conrad":
+                self.suche_auf_conrad(webseite)
+            elif webseite == "Kosatec":
+                self.suche_auf_kosatec(webseite)
+            elif webseite == "Hornbach": 
+                self.suche_auf_hornbach(webseite)
+            elif webseite =="Contorion":
+                self.suche_auf_contorion(webseite)
+            elif webseite == "Gastro Teile Shop":
+                self.suche_auf_gastroteileshop(webseite)
+            elif webseite == "TiroLED":
+                self.suche_auf_tiroled(webseite)
+            elif webseite == "Megabad":
+                self.suche_auf_megabad(webseite)
+            elif webseite == "IPS":
+                self.suche_auf_ips_shop(webseite)
+            elif webseite == "Brewes":
+                self.suche_auf_brewes(webseite)
+            elif webseite == "Delker":
+                self.suche_auf_delker(webseite)
+            elif webseite == "Knauss":
+                self.suche_auf_knauss(webseite)
+            elif webseite == "Schildershop24":
+                self.suche_auf_schildershop24(webseite)
+            elif webseite == "Häfele":
+                self.suche_auf_haefele(webseite)
+            elif webseite == "Esmeyer":
+                self.suche_auf_esmeyer(webseite)
+            elif webseite == "Papstar":
+                 self.suche_auf_papstar(webseite)
+            elif webseite == "Lusini":
+                self.suche_auf_lusini(webseite)
+            elif webseite == "Hygi":
+                self.suche_auf_hygi(webseite)
+            elif webseite == "Schafferer":
+                self.suche_auf_schafferer(webseite)
+            elif webseite == "Gastronomie Kaufhaus":
+                self.suche_auf_gastronomie_kaufhaus(webseite)
+            elif webseite == "Böttcher":
+                self.suche_auf_boettcher(webseite)
+            elif webseite == "Büroshop24":
+                self.suche_auf_bueroshop24(webseite)
+    
         except Exception as e:
-            self.error_message = f"Fehler bei der Suche: {e}"
+            print(f"Fehler bei der Suche auf {webseite}: {e}")
-            
-        
-        
 
-    def suche_auf_haefele(self):
+    def suche_auf_haefele(self,webseite):
+
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "inputSearchTerm")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "inputSearchTerm")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.ID, "inputSearchTerm")
+        search_box = 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):
+    def suche_auf_brewes(self, webseite):
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "search")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.ID, "search")
+        search_box = 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):
+    def suche_auf_conrad(self, webseite):
         # 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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "header-search")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "header-search")))
 
         # Suchbegriff eingeben
-        search_box = self.driver.find_element(By.ID, "header-search")
+        search_box = 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):
+    def suche_auf_contorion(self, webseite):
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))
 
         # Suchbegriff eingeben
-        search_box = self.driver.find_element(By.ID, "search-input")
+        search_box = 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):
+    def suche_auf_reichelt(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 60).until(EC.presence_of_element_located((By.ID, "searchbutton")))
+        WebDriverWait(driver, 60).until(EC.presence_of_element_located((By.ID, "searchbutton")))
 
             # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.ID, "quicksearch_new")
+        search_box = driver.find_element(By.ID, "quicksearch_new")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)
 
@@ -172,315 +175,315 @@ class SearchThread(QThread):
         search_button = self.driver.find_element(By.ID, "searchbutton")
         search_button.click()
 
-    def suche_auf_kosatec(self):
+    def suche_auf_kosatec(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, "input[name='search']")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, "input[name='search']")))
 
         # Suchbegriff eingeben
-        search_box = self.driver.find_element(By.CSS_SELECTOR, "input[name='search']")
+        search_box = 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):
+    def suche_auf_hornbach(self,webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "global_search")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "global_search")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.NAME, "global_search")
+        search_box = 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):
+    def suche_auf_gastroteileshop(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
 
         # Warten, bis das Suchfeld sichtbar ist
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "search-input")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "search-input")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.CLASS_NAME, "search-input")
+        search_box = 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):
+    def suche_auf_tiroled(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.NAME, "search")
+        search_box = 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):
+    def suche_auf_megabad(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-bar-input")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "search-bar-input")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.ID, "search-bar-input")
+        search_box = 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):
+    def suche_auf_ips_shop(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.NAME, "query")
+        search_box = 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):
+    def suche_auf_delker(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))
 
         # Suchbegriff eingeben und Suche starten 
-        search_box = self.driver.find_element(By.NAME, "query")
+        search_box = 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):
+    def suche_auf_knauss(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "sSearch")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "sSearch")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.NAME, "sSearch")
+        search_box = 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):
+    def suche_auf_schildershop24(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-query-stichwort_neu")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "search-query-stichwort_neu")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.ID, "search-query-stichwort_neu")
+        search_box = 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):
+    def suche_auf_esmeyer(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.NAME, "search")
+        search_box = 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):
+    def suche_auf_papstar(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "search")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.ID, "search")
+        search_box = 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):
+    def suche_auf_lusini(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.ID, "search-input")
+        search_box = 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):
+    def suche_auf_hygi(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "qbox")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "qbox")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.ID, "qbox")
+        search_box = 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):
+    def suche_auf_schafferer(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "quicksearch-input")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "quicksearch-input")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.ID, "quicksearch-input")
+        search_box = 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):
+    def suche_auf_gastronomie_kaufhaus(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "searchParam")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "searchParam")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.ID, "searchParam")
+        search_box = 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):
+    def suche_auf_boettcher(self, webseite):
     # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "autocomplete-0-input")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "autocomplete-0-input")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.ID, "autocomplete-0-input")
+        search_box = 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):
+    def suche_auf_bueroshop24(self, webseite):
         # WebDriver initialisieren
-        self.driver = webdriver.Edge()
+        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
-        self.driver.get(search_url)
+        driver.get(search_url)
-        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "searchTerm")))
+        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "searchTerm")))
 
         # Suchbegriff eingeben und Suche starten
-        search_box = self.driver.find_element(By.ID, "searchTerm")
+        search_box = driver.find_element(By.ID, "searchTerm")
         search_box.clear()  # Falls vorheriger Text vorhanden ist
         search_box.send_keys(self.search_term)