feat: Enhance driver robustness, add multi-tab support and ad handling

Refactor driver initialization to prioritize Selenium Manager with webdriver_manager as a fallback. Increase WebDriverWait timeout for improved handling of dynamic content and slow page loads.

Implement multi-tab viewing functionality in main.py based on tab_amount in config.json. Add logic to accept cookies and skip ads for a smoother viewing experience. Introduce helper methods in the Bot class for better code organization and error handling.

Update config.json with example values and README.md for clarity. Add .github/ directory for project automation. Remove Opera browser support.

Author: timhauke

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @gavintranquilino/maintainers @VectoDE

README.md

@@ -34,7 +34,7 @@ pip install webdriver-manager selenium requests
 
 ```json
 {
-    "website": "YOUR VIDEO", 
+    "website": "YOUR VIDEO",
     "tab_amount": 3,
     "watch_time": 35,
     "view_cycles": 5,

config.json

@@ -1,7 +1,7 @@
 {
-    "website": "YOUR VIDEO", 
+    "website": "your video url",
     "tab_amount": 3,
-    "watch_time": 35,
+    "watch_time": 28,
     "view_cycles": 5,
-    "browser": "firefox"
+    "browser": "chrome"
 }

driver.py

@@ -3,64 +3,185 @@
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import (
+    TimeoutException,
+    InvalidSessionIdException,
+    NoSuchWindowException,
+    StaleElementReferenceException,
+    ElementClickInterceptedException,
+)
 
 from webdriver_manager.chrome import ChromeDriverManager 
 from webdriver_manager.firefox import GeckoDriverManager
 from webdriver_manager.opera import OperaDriverManager 
 from webdriver_manager.microsoft import IEDriverManager, EdgeChromiumDriverManager
+from selenium.webdriver.chrome.service import Service as ChromeService
+from selenium.webdriver.firefox.service import Service as FirefoxService
+from selenium.webdriver.ie.service import Service as IEService
+from selenium.webdriver.edge.service import Service as EdgeService
 
 def get_driver(browser):
     """Get the webdriver specified in configuration"""
 
     # Browser name aliases
     chrome = ('chrome', 'google', 'google chrome', 'googlechrome', 'google-chrome', 'google_chrome')
     firefox = ('firefox', 'ff', 'mozilla', 'gecko', 'geckodriver', 'fire fox', 'fire_fox', 'fire-fox')
-    opera = ('opera', 'opera gx', 'operagx', 'opera_gx', 'opera-gx')
     explorer = ('explorer', 'ie', 'internet explorer', 'internet-explorer', 'internet_explorer')
     edge = ('edge', 'microsoft edge', 'microsoft_edge', 'microsoft-edge')
 
     # Download browser binaries according to settings.json
     if browser.lower() in chrome:
-        return webdriver.Chrome(ChromeDriverManager().install())
+        # Prefer built-in Selenium Manager; fallback to webdriver_manager only if needed
+        try:
+            return webdriver.Chrome()
+        except Exception:
+            service = ChromeService(ChromeDriverManager().install())
+            return webdriver.Chrome(service=service)
 
     elif browser.lower() in firefox:
-        return webdriver.Firefox(executable_path=GeckoDriverManager().install())
-
-    elif browser.lower() in opera:
-        return webdriver.Opera(OperaDriverManager().install())
+        try:
+            return webdriver.Firefox()
+        except Exception:
+            service = FirefoxService(GeckoDriverManager().install())
+            return webdriver.Firefox(service=service)
 
     elif browser.lower() in explorer:
-        return webdriver.Ie(IEDriverManager().install())
+        try:
+            return webdriver.Ie()
+        except Exception:
+            service = IEService(IEDriverManager().install())
+            return webdriver.Ie(service=service)
 
     elif browser.lower() in edge:
-        return webdriver.Edge(executable_path=EdgeChromiumDriverManager().install())
+        try:
+            return webdriver.Edge()
+        except Exception:
+            service = EdgeService(EdgeChromiumDriverManager().install())
+            return webdriver.Edge(service=service)
 
     else:
-        raise RuntimeError('Browser not found {}'.format(browser.lower()))
+        raise RuntimeError('Browser not found {}. Supported: Chrome, Firefox, Edge, IE'.format(browser.lower()))
 
 
 class Bot(object):
     """Handle connections"""
 
-    def __init__(self, website, browser):
+    def __init__(self, website, browser, tab_amount=1):
         """Initial function"""
 
+        self.browser = browser
+        self.tab_amount = tab_amount
         self.driver = get_driver(browser)
-        self.website = website  
-        self.wait = WebDriverWait(self.driver, 3)
+        self.website = website
+        # Allow slower page loads/overlays before timing out
+        self.wait = WebDriverWait(self.driver, 20)
         self.presence = EC.presence_of_element_located
         self.visible = EC.visibility_of_element_located
 
     def get_vid(self):
         """Open the YouTube link"""
 
         self.driver.get(self.website)
-    
+        self._accept_cookies()
+
     def play_video(self):
         """Click on the play button"""
 
-        self.wait.until(self.visible((By.ID, "video-title")))
-        self.driver.find_element_by_xpath("//button[@class='ytp-large-play-button ytp-button']").click()
+        # Ensure we are on the desired video (avoid autoplay chaining to another video)
+        if self.website not in self.driver.current_url:
+            self.driver.get(self.website)
+
+        # Wait for player to be ready and ensure play button is clickable
+        self._accept_cookies()
+        self.wait.until(self.presence((By.TAG_NAME, "video")))
+        self._dismiss_overlays()
+        if not self._click_play_button():
+            # Fallback: try to start video via JS if button not found/clickable
+            self.driver.execute_script("""
+                const v = document.querySelector('video');
+                if (v) { v.muted = false; v.play().catch(()=>{}); }
+            """)
+
+    def _dismiss_overlays(self):
+        """Attempt to close common YouTube overlays such as cookie consent backdrops."""
+
+        # Remove overlay backdrops that block clicks
+        self.driver.execute_script(
+            "document.querySelectorAll('tp-yt-iron-overlay-backdrop').forEach(e => e.remove());"
+        )
+
+        # Try to click consent buttons if present
+        consent_selectors = [
+            "//button[normalize-space()='I agree']",
+            "//button[normalize-space()='Accept all']",
+            "//button[normalize-space()='Alle akzeptieren']",
+            "//button[normalize-space()='Ich stimme zu']",
+        ]
+
+        for selector in consent_selectors:
+            try:
+                btn = WebDriverWait(self.driver, 3).until(
+                    EC.element_to_be_clickable((By.XPATH, selector))
+                )
+                btn.click()
+                break
+            except TimeoutException:
+                continue
+
+    def _accept_cookies(self):
+        """Accept YouTube/Google cookie banners if present."""
+
+        consent_selectors = [
+            "//button[normalize-space()='I agree']",
+            "//button[normalize-space()='Accept all']",
+            "//button[normalize-space()='Alle akzeptieren']",
+            "//button[normalize-space()='Ich stimme zu']",
+            "//button[normalize-space()='Zustimmen und fortfahren']",
+            "//button[@aria-label='Accept all']",
+            "//button[@aria-label='Alle akzeptieren']",
+        ]
+
+        try:
+            WebDriverWait(self.driver, 5).until(lambda d: True)
+            for selector in consent_selectors:
+                buttons = self.driver.find_elements(By.XPATH, selector)
+                for btn in buttons:
+                    if btn.is_displayed() and btn.is_enabled():
+                        btn.click()
+                        return
+        except Exception:
+            # If anything goes wrong, just proceed; the overlay handler will try again.
+            pass
+
+    def _get_play_button(self):
+        """Return a clickable play button element if available."""
+
+        try:
+            return self.wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, ".ytp-play-button")))
+        except TimeoutException:
+            buttons = self.driver.find_elements(By.CSS_SELECTOR, ".ytp-play-button")
+            for btn in buttons:
+                if btn.is_displayed() and btn.is_enabled():
+                    return btn
+        return None
+
+    def _click_play_button(self):
+        """Try clicking the play button with retries to avoid stale references."""
+
+        for _ in range(3):
+            btn = self._get_play_button()
+            if not btn:
+                continue
+            try:
+                self.driver.execute_script(
+                    "arguments[0].scrollIntoView({block: 'center', inline: 'center'});", btn
+                )
+                self.driver.execute_script("arguments[0].click();", btn)
+                return True
+            except (StaleElementReferenceException, ElementClickInterceptedException):
+                self._dismiss_overlays()
+                continue
+        return False
 
     def clear_cache(self):
         """Clear the cache"""
@@ -70,15 +191,52 @@ def clear_cache(self):
     def refresh(self):
         """Refresh the current tab"""
 
+        # Reload the intended video instead of refreshing whatever autoplay selected
         self.driver.implicitly_wait(5)
-        self.driver.refresh()
+        self.driver.get(self.website)
+        self._accept_cookies()
 
     def switch_tab(self, tab):
         """Switch to the specified tab"""
 
-        self.driver.switch_to.window(self.driver.window_handles[tab])
+        try:
+            self.driver.switch_to.window(self.driver.window_handles[tab])
+        except (InvalidSessionIdException, NoSuchWindowException, IndexError):
+            # Browser/tab closed or session lost; try to rebuild session so script does not exit
+            self._restart_session()
+            try:
+                self.driver.switch_to.window(self.driver.window_handles[tab])
+            except Exception:
+                pass
 
     def new_tab(self):
         """Open a blank new tab"""
 
         self.driver.execute_script("window.open('about:blank');")
+
+    def _restart_session(self):
+        """Rebuild the browser session if it was lost."""
+
+        try:
+            self.driver.quit()
+        except Exception:
+            pass
+
+        self.driver = get_driver(self.browser)
+        self.wait = WebDriverWait(self.driver, 20)
+
+        # Reopen tabs and load the target website in each
+        handles_needed = max(self.tab_amount, 1)
+        # Open first tab and load
+        self.driver.get(self.website)
+        self._accept_cookies()
+
+        # Create remaining tabs
+        for _ in range(handles_needed - 1):
+            self.new_tab()
+
+        # Load website in every tab
+        for handle in self.driver.window_handles:
+            self.driver.switch_to.window(handle)
+            self.driver.get(self.website)
+            self._accept_cookies()

main.py

@@ -18,7 +18,8 @@ def get_config():
 def init_tabs(website, tab_amount):
     """Opens tabs according to tab amount set in config.json"""
 
-    for _ in range(tab_amount):
+    # First tab already exists; only open the remaining tabs
+    for _ in range(max(tab_amount - 1, 0)):
         website.new_tab()
 
 def open_links(website, tab_amount):
@@ -51,7 +52,7 @@ def main():
     print('Initilization')
     config = get_config()
 
-    website = driver.Bot(config['website'], config['browser'])
+    website = driver.Bot(config['website'], config['browser'], config['tab_amount'])
 
     print('Opening new tabs')
     init_tabs(website, config['tab_amount'])