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.
This commit is contained in:
Domenik Rath 2023-11-24 09:51:02 +01:00
parent a401041df3
commit f083a15c14
2 changed files with 172 additions and 169 deletions

BIN
.DS_Store vendored

Binary file not shown.

View File

@ -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 = []
for webseite in self.selected_webpages:
# Fügen hier andere Suchfunktionen hinzu
# WebDriver initialisieren
self.driver = webdriver.Edge()
futures = {executor.submit(self.start_search_on_webseite, webseite): webseite for webseite in self.selected_webpages}
if webseite == "Reichelt":
futures.append(executor.submit(self.suche_auf_reichelt))
elif webseite == "Conrad":
futures.append(executor.submit(self.suche_auf_conrad))
elif webseite == "Kosatec":
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 concurrent.futures.as_completed(futures):
try:
future.result() # Warte auf das Ende der Suche
except Exception as e:
self.error_message = f"Fehler bei der Suche: {e}"
for future in futures:
future.result() # Warte auf das Ende der Suche
def initialize_driver(self, webseite):
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "inputSearchTerm")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "header-search")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 60).until(EC.presence_of_element_located((By.ID, "searchbutton")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, "input[name='search']")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "global_search")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-bar-input")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "sSearch")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-query-stichwort_neu")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "qbox")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "quicksearch-input")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "searchParam")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "autocomplete-0-input")))
driver.get(search_url)
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)
WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "searchTerm")))
driver.get(search_url)
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)