sample_demo_code.py

import gradio as gr
import undetected_chromedriver as uc
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 WebDriverException, TimeoutException
from PIL import Image
from io import BytesIO
import time
import random
import os

def create_stealth_driver(headless=False, mobile_view=False):
    """Create an undetected Chrome driver"""
    try:
        # Configure undetected-chromedriver options
        options = uc.ChromeOptions()
        
        # Basic options
        options.add_argument("--no-sandbox")
        options.add_argument("--disable-dev-shm-usage")
        options.add_argument("--disable-gpu")
        options.add_argument("--disable-software-rasterizer")
        
        # Performance optimizations
        options.add_argument("--disable-extensions")
        options.add_argument("--disable-plugins")
        options.add_argument("--disable-images")  # Faster loading
        
        # Mobile view configuration
        if mobile_view:
            mobile_emulation = {
                "deviceMetrics": {"width": 375, "height": 812, "pixelRatio": 3.0},
                "userAgent": "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15"
            }
            options.add_experimental_option("mobileEmulation", mobile_emulation)
        
        # Headless mode if requested
        if headless:
            options.add_argument("--headless=new")
        
        # Create undetected Chrome driver
        driver = uc.Chrome(
            options=options,
            version_main=None,  # Auto-detect Chrome version
            driver_executable_path=None,  # Auto-download chromedriver
            browser_executable_path=None,  # Use system Chrome
            use_subprocess=True,
            debug=False
        )
        
        # Set window size
        if not mobile_view:
            driver.set_window_size(1920, 1080)
        
        return driver
        
    except Exception as e:
        print(f"Failed to create undetected Chrome driver: {e}")
        return None

def wait_for_cloudflare(driver, timeout=30):
    """Wait for Cloudflare challenge to complete"""
    try:
        # Wait for page to be ready
        WebDriverWait(driver, timeout).until(
            lambda d: d.execute_script("return document.readyState") == "complete"
        )
        
        # Check for Cloudflare challenge indicators
        cf_selectors = [
            "div[class*='cf-']",
            "div[class*='cloudflare']",
            "div[id*='challenge']",
            "div[class*='challenge']"
        ]
        
        start_time = time.time()
        while time.time() - start_time < timeout:
            # Check if we're still on a challenge page
            current_url = driver.current_url
            page_source = driver.page_source.lower()
            
            # Common Cloudflare challenge indicators
            cf_indicators = [
                'checking your browser',
                'cloudflare',
                'please wait',
                'ddos protection',
                'checking if the site connection is secure'
            ]
            
            if not any(indicator in page_source for indicator in cf_indicators):
                print("✅ Cloudflare challenge passed or not present")
                return True
                
            print(f"⏳ Waiting for Cloudflare challenge... ({int(time.time() - start_time)}s)")
            time.sleep(2)
            
        print("⚠️ Cloudflare challenge timeout")
        return False
        
    except TimeoutException:
        print("⚠️ Page load timeout")
        return False

def take_screenshot(url, wait_time=10, use_mobile=False, headless_mode=True, retry_count=2):
    """Take a screenshot with undetected Chrome"""
    if not url.startswith(('http://', 'https://')):
        url = 'https://' + url
    
    for attempt in range(retry_count + 1):
        driver = None
        try:
            print(f"📸 Attempt {attempt + 1} to screenshot: {url}")
            
            # Create undetected Chrome driver
            driver = create_stealth_driver(headless=headless_mode, mobile_view=use_mobile)
            if not driver:
                continue
            
            # Navigate with human-like delay
            time.sleep(random.uniform(2, 4))
            print("🌐 Navigating to URL...")
            driver.get(url)
            
            # Wait for Cloudflare if present
            if not wait_for_cloudflare(driver):
                if attempt < retry_count:
                    print("🔄 Retrying due to protection challenge...")
                    continue
                else:
                    print("❌ Failed to bypass protection after all attempts")
            
            # Additional wait for page to fully load
            print(f"⏳ Waiting {wait_time}s for page to load...")
            time.sleep(wait_time)
            
            # Human-like behavior: scroll to trigger lazy loading
            try:
                driver.execute_script("window.scrollTo(0, document.body.scrollHeight/3);")
                time.sleep(1)
                driver.execute_script("window.scrollTo(0, document.body.scrollHeight/2);")
                time.sleep(1)
                driver.execute_script("window.scrollTo(0, 0);")
                time.sleep(2)
            except Exception as e:
                print(f"Scroll behavior failed: {e}")
            
            # Take screenshot
            print("📷 Capturing screenshot...")
            screenshot = driver.get_screenshot_as_png()
            
            if len(screenshot) < 1000:
                print("⚠️ Screenshot too small, likely error page")
                if attempt < retry_count:
                    continue
                return None
            
            print("✅ Screenshot captured successfully!")
            return Image.open(BytesIO(screenshot))
            
        except WebDriverException as e:
            print(f"❌ WebDriver error (attempt {attempt + 1}): {e}")
            if attempt < retry_count:
                time.sleep(random.uniform(3, 6))
                continue
                
        except Exception as e:
            print(f"❌ Unexpected error (attempt {attempt + 1}): {e}")
            if attempt < retry_count:
                continue
                
        finally:
            if driver:
                try:
                    driver.quit()
                except:
                    pass
    
    print("❌ All attempts failed")
    return None

# Gradio interface with enhanced features
def screenshot_interface(url, wait_time, use_mobile_view, headless_mode):
    """Gradio interface function"""
    if not url.strip():
        return None, "Please enter a valid URL"
    
    # Adjust wait time based on user input
    wait_seconds = int(wait_time) if wait_time else 10
    
    try:
        result = take_screenshot(url, wait_seconds, use_mobile_view, headless_mode)
        if result:
            return result, "✅ Screenshot captured successfully with undetected Chrome!"
        else:
            return None, "❌ Failed to capture screenshot. The site may have very strong protection."
    except Exception as e:
        return None, f"❌ Error: {str(e)}"

# Create Gradio interface
iface = gr.Interface(
    fn=screenshot_interface,
    inputs=[
        gr.Textbox(
            label="Website URL", 
            placeholder="https://example.com or example.com",
            value="https://github.com"
        ),
        gr.Slider(
            minimum=5, 
            maximum=30, 
            value=10, 
            step=1,
            label="Wait Time (seconds)"
        ),
        gr.Checkbox(
            label="Mobile View", 
            value=False
        ),
        gr.Checkbox(
            label="Headless Mode (Hidden Browser)", 
            value=True
        )
    ],
    outputs=[
        gr.Image(type="pil", label="Screenshot"),
        gr.Textbox(label="Status", lines=2)
    ],
    title="🔍 Undetected Chrome Screenshot Tool",
    description="Advanced screenshot tool using undetected-chromedriver to bypass Cloudflare and other bot protections.",
    theme="default"
)

if __name__ == "__main__":
    iface.launch(
        share=False,
        inbrowser=True,
        show_error=True
    )