Spaces:

broadfield-dev
/

browser-gradio

Running

File size: 10,507 Bytes
# app.py

import gradio as gr
import time
import datetime

# --- Core Browser Logic (Slightly modified for Gradio) ---
# Changes:
# - Removed print() statements. Methods now return status/log messages.
# - Removed time.sleep() as Gradio handles user feedback.

class Tab:
    """Represents a single browser tab with its own history."""
    def __init__(self, homepage):
        self.history = []
        self.current_index = -1
        self.homepage = homepage
        self.navigate(self.homepage)

    def navigate(self, url):
        """Navigates to a new URL, clearing any 'forward' history."""
        if self.current_index < len(self.history) - 1:
            self.history = self.history[:self.current_index + 1]
        self.history.append(url)
        self.current_index += 1
        return f"Navigating to {url}..."

    def go_back(self):
        if self.current_index > 0:
            self.current_index -= 1
            return f"Going back to {self.current_url()}"
        return "No more history to go back to."

    def go_forward(self):
        if self.current_index < len(self.history) - 1:
            self.current_index += 1
            return f"Going forward to {self.current_url()}"
        return "No more history to go forward to."

    def current_url(self):
        return self.history[self.current_index] if self.current_index != -1 else "about:blank"

class PseudoBrowser:
    """Simulates a web browser's core functionality."""
    def __init__(self):
        self.homepage = "https://www.startpage.com"
        self.tabs = [Tab(self.homepage)]
        self.active_tab_index = 0
        self.bookmarks = set()
        self.global_history = []
        self.cache = {}

    def _get_active_tab(self):
        return self.tabs[self.active_tab_index]

    def _fetch_content(self, url, refresh=False):
        """Simulates fetching content, using a cache."""
        log = ""
        if url in self.cache and not refresh:
            log += f"⚡️ Loading '{url}' from cache.\n"
            content = self.cache[url]
        else:
            log += f"☁️ Fetching '{url}' from network...\n"
            content = f"<html><body><h1>Welcome to {url}</h1><p><i>Content 'rendered' at {datetime.datetime.now().strftime('%H:%M:%S')}</i></p></body></html>"
            self.cache[url] = content
        return content, log

    def open_url(self, url):
        tab = self._get_active_tab()
        log = tab.navigate(url)
        self.global_history.append((datetime.datetime.now(), url))
        content, fetch_log = self._fetch_content(url)
        return content, log + "\n" + fetch_log

    def back(self):
        tab = self._get_active_tab()
        log = tab.go_back()
        content, fetch_log = self._fetch_content(tab.current_url())
        return content, log + "\n" + fetch_log

    def forward(self):
        tab = self._get_active_tab()
        log = tab.go_forward()
        content, fetch_log = self._fetch_content(tab.current_url())
        return content, log + "\n" + fetch_log
    
    def refresh(self):
        tab = self._get_active_tab()
        url = tab.current_url()
        log = f"🔄 Refreshing {url}..."
        content, fetch_log = self._fetch_content(url, refresh=True)
        return content, log + "\n" + fetch_log

    def new_tab(self):
        new_tab = Tab(self.homepage)
        self.tabs.append(new_tab)
        self.active_tab_index = len(self.tabs) - 1
        content, fetch_log = self._fetch_content(new_tab.current_url())
        return content, f"✨ New tab opened.\n" + fetch_log

    def close_tab(self):
        if len(self.tabs) == 1:
            return None, "❌ Cannot close the last tab!"
        
        closed_tab = self.tabs.pop(self.active_tab_index)
        log = f"💣 Tab ({closed_tab.current_url()}) closed."
        if self.active_tab_index >= len(self.tabs):
            self.active_tab_index = len(self.tabs) - 1
        
        active_tab = self._get_active_tab()
        content, fetch_log = self._fetch_content(active_tab.current_url())
        return content, log + "\n" + fetch_log

    def switch_tab(self, tab_label):
        # The label is "Tab 0: https://..."
        index = int(tab_label.split(":")[0].replace("Tab", "").strip())
        if 0 <= index < len(self.tabs):
            self.active_tab_index = index
            tab = self._get_active_tab()
            content, fetch_log = self._fetch_content(tab.current_url())
            return content, f"Switched to Tab {index}.\n" + fetch_log
        return None, "❌ Invalid tab index."

    def add_bookmark(self):
        url = self._get_active_tab().current_url()
        if url not in self.bookmarks:
            self.bookmarks.add(url)
            return f"⭐ Bookmarked: {url}"
        return f"ℹ️ Already bookmarked: {url}"
    
# --- Gradio UI and Event Handlers ---

def update_ui_components(browser: PseudoBrowser):
    """Generates all UI component values from the browser state."""
    # Main Content
    active_tab = browser._get_active_tab()
    content, _ = browser._fetch_content(active_tab.current_url())
    url_text = active_tab.current_url()
    
    # Tab Selector
    tab_choices = [f"Tab {i}: {tab.current_url()}" for i, tab in enumerate(browser.tabs)]
    active_tab_label = f"Tab {browser.active_tab_index}: {active_tab.current_url()}"
    
    # History
    history_md = "### 📜 Global History\n"
    if not browser.global_history:
        history_md += "_(empty)_"
    else:
        for ts, url in reversed(browser.global_history[-10:]): # Show last 10
            history_md += f"- `{ts.strftime('%H:%M:%S')}`: {url}\n"

    # Bookmarks
    bookmarks_md = "### 📚 Bookmarks\n"
    if not browser.bookmarks:
        bookmarks_md += "_(empty)_"
    else:
        for bm in sorted(list(browser.bookmarks)):
            bookmarks_md += f"- ⭐ {bm}\n"
            
    return {
        html_view: gr.HTML(value=content),
        url_textbox: gr.Textbox(value=url_text),
        tab_selector: gr.Radio(choices=tab_choices, value=active_tab_label, label="Active Tabs"),
        history_display: gr.Markdown(history_md),
        bookmarks_display: gr.Markdown(bookmarks_md)
    }

# --- Event Handlers ---

def handle_go(browser_state, url):
    content, log = browser_state.open_url(url)
    return {
        **update_ui_components(browser_state),
        log_display: gr.Textbox(log)
    }

def handle_back(browser_state):
    content, log = browser_state.back()
    return {
        **update_ui_components(browser_state),
        log_display: gr.Textbox(log)
    }

def handle_forward(browser_state):
    content, log = browser_state.forward()
    return {
        **update_ui_components(browser_state),
        log_display: gr.Textbox(log)
    }
    
def handle_refresh(browser_state):
    content, log = browser_state.refresh()
    return {
        **update_ui_components(browser_state),
        log_display: gr.Textbox(log)
    }

def handle_new_tab(browser_state):
    content, log = browser_state.new_tab()
    return {
        **update_ui_components(browser_state),
        log_display: gr.Textbox(log)
    }

def handle_close_tab(browser_state):
    content, log = browser_state.close_tab()
    # Update UI components. If content is None, it means the last tab wasn't closed.
    updated_components = update_ui_components(browser_state)
    if content is not None:
        updated_components[html_view] = gr.HTML(value=content)
    
    return {
        **updated_components,
        log_display: gr.Textbox(log)
    }

def handle_switch_tab(browser_state, tab_label):
    content, log = browser_state.switch_tab(tab_label)
    return {
        **update_ui_components(browser_state),
        log_display: gr.Textbox(log)
    }

def handle_add_bookmark(browser_state):
    log = browser_state.add_bookmark()
    return {
        **update_ui_components(browser_state),
        log_display: gr.Textbox(log)
    }

# --- Gradio Interface Layout ---

with gr.Blocks(theme=gr.themes.Soft(), title="Pseudo Browser") as demo:
    browser_state = gr.State(PseudoBrowser())

    gr.Markdown("# 🌐 Pseudo Browser Demo")
    gr.Markdown("A simulation of a web browser's state and actions, built with Python and Gradio.")

    with gr.Row():
        with gr.Column(scale=3):
            # URL and Navigation Controls
            with gr.Row():
                back_btn = gr.Button("◀")
                forward_btn = gr.Button("▶")
                refresh_btn = gr.Button("🔄")
                url_textbox = gr.Textbox(label="URL", placeholder="https://example.com", interactive=True)
                go_btn = gr.Button("Go", variant="primary")
                bookmark_btn = gr.Button("⭐")
            
            # Main "rendered" content view
            html_view = gr.HTML(value="<html><body><h1>Welcome!</h1></body></html>")
            
            # Log display
            log_display = gr.Textbox(label="Log", interactive=False)

        with gr.Column(scale=1):
            # Tab Management
            with gr.Row():
                new_tab_btn = gr.Button("➕ New Tab")
                close_tab_btn = gr.Button("❌ Close Active Tab")
            tab_selector = gr.Radio(choices=[], label="Active Tabs", interactive=True)
            
            # Accordion for History and Bookmarks
            with gr.Accordion("History & Bookmarks", open=True):
                history_display = gr.Markdown("...")
                bookmarks_display = gr.Markdown("...")

    # --- Component Wiring ---
    
    # Define all outputs that can be updated
    outputs = [html_view, url_textbox, tab_selector, history_display, bookmarks_display, log_display]

    # Initial load
    demo.load(
        fn=lambda state: {**update_ui_components(state), log_display: "🚀 Browser Initialized!"},
        inputs=[browser_state],
        outputs=outputs
    )

    # Wire up buttons
    go_btn.click(handle_go, [browser_state, url_textbox], outputs)
    url_textbox.submit(handle_go, [browser_state, url_textbox], outputs)
    back_btn.click(handle_back, [browser_state], outputs)
    forward_btn.click(handle_forward, [browser_state], outputs)
    refresh_btn.click(handle_refresh, [browser_state], outputs)
    
    new_tab_btn.click(handle_new_tab, [browser_state], outputs)
    close_tab_btn.click(handle_close_tab, [browser_state], outputs)
    tab_selector.input(handle_switch_tab, [browser_state, tab_selector], outputs)
    
    bookmark_btn.click(handle_add_bookmark, [browser_state], outputs)


demo.launch()