Upload folder using huggingface_hub

ankigen_core/card_generator.py

@@ -52,16 +52,6 @@ GENERATION_MODES = [
         "label": "Single Subject",
         "description": "Generate cards for a specific topic",
     },
-    {
-        "value": "text",
-        "label": "From Text",
-        "description": "Generate cards from provided text",
-    },
-    {
-        "value": "web",
-        "label": "From Web",
-        "description": "Generate cards from a web page URL",
-    },
 ]
 
 # --- Core Functions --- (Moved and adapted from app.py)
@@ -279,97 +269,6 @@ def get_dataframe_columns() -> list[str]:
     ]
 
 
-# This function might be specific to the old crawler flow if AnkiCardData is only from there.
-# If orchestrate_card_generation now also produces something convertible to AnkiCardData, it might be useful.
-# For now, it's used by generate_cards_from_crawled_content.
-def deduplicate_cards(cards: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    """Deduplicates a list of card dictionaries based on the 'Question' field."""
-    seen_questions = set()
-    unique_cards = []
-    for card_dict in cards:
-        question = card_dict.get("Question")
-        if question is None:  # Should not happen if cards are well-formed
-            logger.warning(f"Card dictionary missing 'Question' key: {card_dict}")
-            unique_cards.append(card_dict)  # Keep it if no question to dedupe on
-            continue
-
-        # Normalize whitespace and case for deduplication
-        normalized_question = " ".join(str(question).strip().lower().split())
-        if normalized_question not in seen_questions:
-            seen_questions.add(normalized_question)
-            unique_cards.append(card_dict)
-        else:
-            logger.info(f"Deduplicated card with question: {question}")
-    return unique_cards
-
-
-# --- Modification for generate_cards_from_crawled_content ---
-
-
-def generate_cards_from_crawled_content(
-    all_cards: List[Card],
-) -> List[Dict[str, Any]]:  # Changed AnkiCardData to Card
-    """
-    Processes a list of Card objects (expected to have plain text fields after generate_cards_batch)
-    and formats them into a list of dictionaries suitable for the DataFrame.
-    """
-    if not all_cards:
-        return []
-
-    data_for_dataframe = []
-    for i, card_obj in enumerate(all_cards):
-        # Extract data, assuming it's already plain text from Card object creation
-        topic = (
-            card_obj.metadata.get("topic", f"Crawled Content - Card {i + 1}")
-            if card_obj.metadata
-            else f"Crawled Content - Card {i + 1}"
-        )
-
-        # Ensure list-based metadata are joined as plain strings for DataFrame
-        prerequisites = (
-            card_obj.metadata.get("prerequisites", []) if card_obj.metadata else []
-        )
-        learning_outcomes = (
-            card_obj.metadata.get("learning_outcomes", []) if card_obj.metadata else []
-        )
-
-        prerequisites_str = strip_html_tags(
-            ", ".join(prerequisites)
-            if isinstance(prerequisites, list)
-            else str(prerequisites)
-        )
-        learning_outcomes_str = strip_html_tags(
-            ", ".join(learning_outcomes)
-            if isinstance(learning_outcomes, list)
-            else str(learning_outcomes)
-        )
-        difficulty_str = strip_html_tags(
-            str(
-                card_obj.metadata.get("difficulty", "N/A")
-                if card_obj.metadata
-                else "N/A"
-            )
-        )
-
-        card_dict = {
-            "Index": str(i + 1),
-            "Topic": strip_html_tags(topic),
-            "Card_Type": strip_html_tags(card_obj.card_type or "basic"),
-            "Question": card_obj.front.question or "",  # Should be plain
-            "Answer": card_obj.back.answer or "",  # Should be plain
-            "Explanation": card_obj.back.explanation or "",  # Should be plain
-            "Example": card_obj.back.example or "",  # Should be plain
-            "Prerequisites": prerequisites_str,
-            "Learning_Outcomes": learning_outcomes_str,
-            "Difficulty": difficulty_str,
-            "Source_URL": strip_html_tags(
-                card_obj.metadata.get("source_url", "") if card_obj.metadata else ""
-            ),
-        }
-        data_for_dataframe.append(card_dict)
-    return data_for_dataframe
-
-
 def generate_token_usage_html(token_usage=None):
     """Generate HTML for token usage display"""
     if token_usage and isinstance(token_usage, dict):

ankigen_core/exceptions.py

@@ -41,24 +41,6 @@ class Context7APIError(APIError):
     pass
 
 
-class CrawlerError(AnkigenError):
-    """Base exception for web crawler errors."""
-
-    pass
-
-
-class URLValidationError(CrawlerError):
-    """Raised when URL validation fails."""
-
-    pass
-
-
-class ContentExtractionError(CrawlerError):
-    """Raised when content extraction from web page fails."""
-
-    pass
-
-
 class ExportError(AnkigenError):
     """Base exception for export-related errors."""
 

ankigen_core/llm_interface.py

@@ -2,9 +2,8 @@
 
 import asyncio
 import time
-from typing import Callable, List, Optional, TypeVar
+from typing import Optional, TypeVar
 
-import tiktoken
 from agents import Agent, ModelSettings, Runner, set_default_openai_client
 from openai import (
     APIConnectionError,
@@ -14,15 +13,8 @@ from openai import (
     RateLimitError,
 )
 from pydantic import BaseModel
-from tenacity import (
-    retry,
-    retry_if_exception_type,
-    stop_after_attempt,
-    wait_exponential,
-)
 
 from ankigen_core.logging import logger
-from ankigen_core.models import Card, CardBack, CardFront, CrawledPage
 from ankigen_core.utils import ResponseCache
 
 T = TypeVar("T", bound=BaseModel)
@@ -343,350 +335,3 @@ class OpenAIRateLimiter:
 # This assumes a single rate limit bucket for all calls from this application instance.
 # More sophisticated scenarios might need per-model or per-key limiters.
 openai_rate_limiter = OpenAIRateLimiter()  # Using default 60k TPM for now
-
-
-@retry(
-    stop=stop_after_attempt(3),
-    wait=wait_exponential(multiplier=1, min=2, max=10),
-    retry=retry_if_exception_type(RETRYABLE_OPENAI_ERRORS),
-    before_sleep=lambda retry_state: logger.warning(
-        f"Retrying OpenAI call (attempt {retry_state.attempt_number}) for process_crawled_page due to {retry_state.outcome.exception() if retry_state.outcome else 'unknown reason'}"
-    ),
-)
-async def process_crawled_page(
-    openai_client: AsyncOpenAI,
-    page: CrawledPage,
-    model: str = "gpt-4o",
-    custom_system_prompt: Optional[str] = None,
-    custom_user_prompt_template: Optional[str] = None,
-    max_prompt_content_tokens: int = 6000,
-    cache: Optional[ResponseCache] = None,
-) -> List[Card]:
-    """Process a crawled page and extract structured Card objects using OpenAI.
-
-    Args:
-        openai_client: The OpenAI client instance
-        page: The crawled page to process
-        model: The model to use for generation
-        custom_system_prompt: Optional custom system prompt
-        custom_user_prompt_template: Optional custom user prompt template
-        max_prompt_content_tokens: Maximum tokens for content
-        cache: Optional ResponseCache for page-level caching
-
-    Returns:
-        List of generated Card objects
-    """
-    # Check page-level cache first
-    if cache:
-        cache_key = f"{page.url}:{model}"
-        cached_cards = cache.get(cache_key, "page_cache")
-        if cached_cards is not None:
-            logger.info(f"Using cached cards for page: {page.url}")
-            return cached_cards
-
-    logger.info(
-        f"Processing page: {page.url} with model {model}, max_prompt_content_tokens: {max_prompt_content_tokens}"
-    )
-
-    if not page.text_content or not page.text_content.strip():
-        logger.info(f"Skipping page {page.url} as it has empty text content.")
-        return []
-
-    system_prompt = (
-        custom_system_prompt
-        if custom_system_prompt and custom_system_prompt.strip()
-        else """
-You are an expert Anki card creator. Your task is to generate Anki flashcards from the provided web page content.
-For each card, provide:
-- "front": A dictionary with a "question" field.
-- "back": A dictionary with "answer", "explanation", and "example" fields.
-- "tags": A list of relevant keywords (optional).
-- "source_url": The URL of the page the content was extracted from (this will be provided by the system).
-- "note_type": Specify "Basic" for question/answer cards or "Cloze" for cloze deletion cards. (This will be mapped to "card_type").
-- "metadata": An optional dictionary for additional structured information such as:
-    - "prerequisites": ["list", "of", "prerequisites"]
-    - "learning_outcomes": ["list", "of", "learning", "outcomes"]
-    - "common_misconceptions": ["list", "of", "common", "misconceptions"]
-    - "difficulty": "beginner" | "intermediate" | "advanced"
-    - "topic": "The main topic this card relates to, derived from the content"
-
-Focus on creating clear, concise, and accurate cards that are useful for learning.
-If generating cloze cards, ensure the "front.question" field uses Anki's cloze syntax, e.g., "The capital of {{c1::France}} is Paris."
-Ensure the entire response is a valid JSON object following this structure:
-{
-  "cards": [
-    {
-      "front": {"question": "..."},
-      "back": {"answer": "...", "explanation": "...", "example": "..."},
-      "tags": ["...", "..."],
-      "card_type": "Basic",
-      "metadata": {"difficulty": "beginner", "prerequisites": [], "topic": "..."}
-    },
-    // ... more cards
-  ]
-}
-"""
-    )
-
-    # User Prompt
-    default_user_prompt_template = """
-Please generate Anki cards based on the following content from the URL: {url}
-
-Content:
-{content}
-
-Generate a few high-quality Anki cards from this content.
-"""
-    user_prompt: str
-    if custom_user_prompt_template and custom_user_prompt_template.strip():
-        try:
-            user_prompt = custom_user_prompt_template.format(
-                url=page.url, content=page.text_content
-            )
-        except KeyError as e:
-            logger.warning(
-                f"Custom user prompt template for {page.url} is malformed (missing key {e}). Falling back to default."
-            )
-            user_prompt = default_user_prompt_template.format(
-                url=page.url, content=page.text_content
-            )
-    else:
-        user_prompt = default_user_prompt_template.format(
-            url=page.url, content=page.text_content
-        )
-    # --- End Prompt Definition ---
-
-    try:
-        encoding = tiktoken.encoding_for_model(model)
-    except KeyError:
-        logger.warning(
-            f"Tiktoken model {model} not found, using cl100k_base for token estimation and truncation."
-        )
-        encoding = tiktoken.get_encoding("cl100k_base")
-
-    prompt_structure_tokens = len(encoding.encode(system_prompt + user_prompt))
-    available_tokens_for_content = max_prompt_content_tokens - prompt_structure_tokens
-    if available_tokens_for_content <= 0:
-        logger.error(
-            f"Max prompt tokens ({max_prompt_content_tokens}) too small for prompt structure for page {page.url}. Cannot process."
-        )
-        return []
-
-    page_content_for_prompt = page.text_content or ""
-    content_tokens = encoding.encode(page_content_for_prompt)
-    if len(content_tokens) > available_tokens_for_content:
-        truncated_content_tokens = content_tokens[:available_tokens_for_content]
-        page_content_for_prompt = encoding.decode(truncated_content_tokens)
-        logger.warning(
-            f"Content for page {page.url} was truncated from {len(content_tokens)} tokens "
-            f"to {len(truncated_content_tokens)} tokens to fit model's context window (limit: {max_prompt_content_tokens} for content portion)."
-        )
-
-    estimated_request_tokens = prompt_structure_tokens + len(
-        encoding.encode(page_content_for_prompt)
-    )
-    await openai_rate_limiter.wait_if_needed(estimated_request_tokens)
-
-    try:
-        logger.debug(
-            f"Attempting to generate cards for {page.url} using model {model}."
-        )
-
-        # Use agents SDK for structured output
-        result = await structured_agent_call(
-            openai_client=openai_client,
-            model=model,
-            instructions=system_prompt,
-            user_input=user_prompt,
-            output_type=GenericJsonOutput,  # Flexible schema for card generation
-            temperature=0.5,
-            timeout=120.0,
-        )
-
-        if result is None:
-            logger.error(f"Invalid or empty response from agent for page {page.url}.")
-            return []
-
-        # Convert Pydantic model to dict for processing
-        parsed_cards = result.model_dump() if isinstance(result, BaseModel) else result
-
-        validated_cards: List[Card] = []
-
-        cards_list_from_json = []
-        if (
-            isinstance(parsed_cards, dict)
-            and "cards" in parsed_cards
-            and isinstance(parsed_cards["cards"], list)
-        ):
-            cards_list_from_json = parsed_cards["cards"]
-            logger.info(
-                f"Found 'cards' key in response from {page.url} with {len(cards_list_from_json)} cards"
-            )
-        elif isinstance(parsed_cards, list):
-            cards_list_from_json = parsed_cards
-        else:
-            logger.error(
-                f"LLM response for {page.url} was not a list or valid dict. Response: {str(parsed_cards)[:200]}..."
-            )
-            return []
-
-        for card_dict in cards_list_from_json:
-            if not isinstance(card_dict, dict):
-                logger.warning(
-                    f"Skipping non-dict card item for {page.url}: {card_dict}"
-                )
-                continue
-
-            try:
-                front_data = card_dict.get("front")
-                back_data = card_dict.get("back")
-
-                if not isinstance(front_data, dict) or "question" not in front_data:
-                    logger.warning(
-                        f"Malformed 'front' data in card_dict for {page.url}: {front_data}. Skipping card."
-                    )
-                    continue
-                if not isinstance(back_data, dict) or "answer" not in back_data:
-                    logger.warning(
-                        f"Malformed 'back' data in card_dict for {page.url}: {back_data}. Skipping card."
-                    )
-                    continue
-
-                metadata_payload = card_dict.get("metadata", {})
-                if not isinstance(metadata_payload, dict):
-                    metadata_payload = {}
-                metadata_payload["source_url"] = page.url
-                if page.title and "topic" not in metadata_payload:
-                    metadata_payload["topic"] = page.title
-
-                tags = card_dict.get("tags", [])
-                if not isinstance(tags, list) or not all(
-                    isinstance(t, str) for t in tags
-                ):
-                    tags = []
-
-                if tags:
-                    metadata_payload["tags"] = tags
-
-                card_obj = Card(
-                    front=CardFront(question=str(front_data["question"])),
-                    back=CardBack(
-                        answer=str(back_data["answer"]),
-                        explanation=str(back_data.get("explanation", "")),
-                        example=str(back_data.get("example", "")),
-                    ),
-                    card_type=str(card_dict.get("card_type", "Basic")),
-                    metadata=metadata_payload,
-                )
-                validated_cards.append(card_obj)
-            except Exception as e:
-                logger.error(
-                    f"Error creating Card object for {page.url} from dict: {card_dict}. Error: {e}",
-                    exc_info=True,
-                )
-
-        if not validated_cards:
-            logger.info(
-                f"No valid Cards generated or parsed from {page.url} after LLM processing."
-            )
-        else:
-            logger.info(
-                f"Successfully generated {len(validated_cards)} Cards from {page.url}."
-            )
-            # Cache successful results for page-level caching
-            if cache:
-                cache_key = f"{page.url}:{model}"
-                cache.set(cache_key, "page_cache", validated_cards)
-                logger.debug(f"Cached {len(validated_cards)} cards for {page.url}")
-
-        return validated_cards
-
-    except Exception as e:
-        logger.error(
-            f"Error processing page {page.url} with agents SDK: {e}", exc_info=True
-        )
-        return []
-
-
-async def process_crawled_pages(
-    openai_client: AsyncOpenAI,
-    pages: List[CrawledPage],
-    model: str = "gpt-4o",
-    max_prompt_content_tokens: int = 6000,
-    max_concurrent_requests: int = 5,
-    custom_system_prompt: Optional[str] = None,
-    custom_user_prompt_template: Optional[str] = None,
-    progress_callback: Optional[Callable[[int, int], None]] = None,
-    cache: Optional[ResponseCache] = None,
-) -> List[Card]:
-    if not pages:
-        logger.info("No pages provided to process_crawled_pages.")
-        return []
-
-    logger.info(
-        f"Starting batch processing of {len(pages)} pages with model {model}. Max concurrent requests: {max_concurrent_requests}."
-    )
-
-    semaphore = asyncio.Semaphore(max_concurrent_requests)
-    tasks = []
-    processed_count = 0
-
-    async def process_with_semaphore(page: CrawledPage):
-        nonlocal processed_count
-        async with semaphore:
-            logger.debug(
-                f"Submitting task for page: {page.url} (Semaphore count: {semaphore._value})"
-            )
-            try:
-                page_cards = await process_crawled_page(
-                    openai_client=openai_client,
-                    page=page,
-                    model=model,
-                    custom_system_prompt=custom_system_prompt,
-                    custom_user_prompt_template=custom_user_prompt_template,
-                    max_prompt_content_tokens=max_prompt_content_tokens,
-                    cache=cache,
-                )
-                if page_cards is None:
-                    logger.warning(
-                        f"process_crawled_page returned None for {page.url}, expected list. Defaulting to empty list."
-                    )
-                    page_cards = []
-
-                logger.info(
-                    f"Completed processing for page: {page.url}. Generated {len(page_cards)} cards."
-                )
-                return page_cards
-            except Exception as e:
-                logger.error(
-                    f"Error in process_with_semaphore for page {page.url}: {e}",
-                    exc_info=True,
-                )
-                return []
-            finally:
-                processed_count += 1
-                if progress_callback:
-                    progress_callback(processed_count, len(pages))
-
-    for page_to_process in pages:
-        tasks.append(asyncio.create_task(process_with_semaphore(page_to_process)))
-
-    results_from_tasks: List[List[Card]] = []
-    for i, future in enumerate(asyncio.as_completed(tasks)):
-        try:
-            result_list = await future
-            if result_list:
-                results_from_tasks.append(result_list)
-        except Exception as e:
-            logger.error(
-                f"Unhandled error gathering result for a page task: {e}", exc_info=True
-            )
-
-    all_cards: List[Card] = []
-    for card_list in results_from_tasks:
-        all_cards.extend(card_list)
-
-    logger.info(
-        f"Finished processing all {len(pages)} pages. Generated {len(all_cards)} Cards in total."
-    )
-    return all_cards

ankigen_core/models.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 from typing import List, Optional
 
 # Module for Pydantic data models
@@ -60,14 +60,3 @@ class LearningSequence(BaseModel):
     cards: List[CardGeneration]
     suggested_study_order: List[str]
     review_recommendations: List[str]
-
-
-class CrawledPage(BaseModel):
-    url: str
-    html_content: str
-    text_content: str
-    title: Optional[str] = None
-    meta_description: Optional[str] = None
-    meta_keywords: Optional[List[str]] = Field(default_factory=list)
-    crawl_depth: int = 0
-    parent_url: Optional[str] = None

ankigen_core/ui_logic.py

@@ -2,68 +2,20 @@
 
 import gradio as gr
 import pandas as pd
-from typing import (
-    Callable,
-    List,
-    Optional,
-    Tuple,
-)
-from urllib.parse import urlparse
+from typing import List
 
-# --- Imports moved from later in the file (Task 7, etc.) ---
-import re  # For URL validation and filename sanitization
-import asyncio
-
-from ankigen_core.crawler import CrawledPage, WebCrawler
-from ankigen_core.llm_interface import (
-    OpenAIClientManager,
-)
-from ankigen_core.card_generator import (
-    generate_cards_from_crawled_content,
-    AVAILABLE_MODELS,
-)
 from ankigen_core.utils import get_logger
+from ankigen_core.models import Card
 
-# Only import models that are actually used in this file
-from ankigen_core.models import (
-    Card,
-    # ModelSettings, # Removed
-    # LearningPathInput, # Removed
-    # LearningPath, # Removed
-    # GeneratedPath, # Removed
-    # SubjectAnalysis, # Removed
-    # SubjectCardRequest, # Removed
-    # TextCardRequest, # Removed
-    # LearningPathRequest, # Removed
-)
-
-# Import agent system for web crawling
-# Agent system is required for web crawling
-from ankigen_core.agents.integration import AgentOrchestrator
-
-AGENTS_AVAILABLE_UI = True
-# --- End moved imports ---
+logger = get_logger()
 
-# Get an instance of the logger for this module
-crawler_ui_logger = get_logger()  # Keep this definition
 
+def update_mode_visibility(mode: str, current_subject: str):
+    """Updates visibility and values of UI elements based on generation mode.
 
-def update_mode_visibility(
-    mode: str,
-    current_subject: str,
-    current_text: str,
-    current_url: str,
-):
-    """Updates visibility and values of UI elements based on generation mode."""
-    is_subject = mode == "subject"
-    is_text = mode == "text"
-    is_web = mode == "web"
-
-    # Determine value persistence or clearing
-    subject_val = current_subject if is_subject else ""
-    text_val = current_text if is_text else ""
-    url_val = current_url if is_web else ""
-
+    Currently only 'subject' mode is supported. This function is kept for
+    future extensibility.
+    """
     # Define standard columns for empty DataFrames
     main_output_df_columns = [
         "Index",
@@ -79,420 +31,20 @@ def update_mode_visibility(
     ]
 
     return (
-        gr.update(visible=is_subject),  # 1 subject_mode (Group)
-        gr.update(visible=is_text),  # 2 text_mode (Group)
-        gr.update(visible=is_web),  # 3 web_mode (Group for crawler UI)
-        gr.update(visible=True),  # 4 cards_output (always visible now)
-        gr.update(value=subject_val),  # 5 subject
-        gr.update(value=text_val),  # 6 source_text
-        gr.update(value=url_val),  # 7 web_crawl_url_input
+        gr.update(visible=True),  # subject_mode (Group) - always visible
+        gr.update(visible=True),  # cards_output - always visible
+        gr.update(value=current_subject),  # subject textbox value
         gr.update(
             value=pd.DataFrame(columns=main_output_df_columns)
-        ),  # 8 output (DataFrame)
+        ),  # output DataFrame
         gr.update(
             value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
             visible=False,
-        ),  # 9 total_cards_html
-    )
-
-
-def create_crawler_main_mode_elements() -> Tuple[
-    List[gr.components.Component],  # ui_components (url_input, max_depth, etc.)
-    gr.Button,  # crawl_button
-    gr.Progress,  # progress_bar
-    gr.Textbox,  # progress_status_textbox
-    gr.Textbox,  # custom_system_prompt
-    gr.Textbox,  # custom_user_prompt_template
-    gr.Checkbox,  # use_sitemap_checkbox
-    gr.Textbox,  # sitemap_url_textbox
-]:
-    """Creates the UI components for the Web Crawler mode integrated into the main tab."""
-    ui_components: List[gr.components.Component] = []
-
-    # URL Input
-    url_input = gr.Textbox(
-        label="Start URL",
-        placeholder="Enter the full URL to start crawling (e.g., https://example.com/docs)",
-        elem_id="crawler_url_input",
-    )
-    ui_components.append(url_input)
-
-    with gr.Row():
-        max_depth_slider = gr.Slider(
-            minimum=0,
-            maximum=5,
-            value=1,
-            step=1,
-            label="Max Crawl Depth",
-            elem_id="crawler_max_depth_slider",
-        )
-        ui_components.append(max_depth_slider)
-
-        crawler_req_per_sec_slider = gr.Slider(
-            minimum=0.1,
-            maximum=10,
-            value=2,
-            step=0.1,
-            label="Requests per Second (Crawler)",
-            elem_id="crawler_req_per_sec_slider",
-        )
-        ui_components.append(crawler_req_per_sec_slider)
-
-    model_choices_ui_crawler = [(m["label"], m["value"]) for m in AVAILABLE_MODELS]
-    default_model_value_crawler = next(
-        (m["value"] for m in AVAILABLE_MODELS if "nano" in m["value"].lower()),
-        AVAILABLE_MODELS[0]["value"] if AVAILABLE_MODELS else "",
-    )
-    model_dropdown = gr.Dropdown(
-        choices=model_choices_ui_crawler,
-        label="AI Model for Content Processing",  # Clarified label
-        value=default_model_value_crawler,
-        elem_id="crawler_model_dropdown",
-        allow_custom_value=True,
+        ),  # total_cards_html
     )
-    ui_components.append(model_dropdown)
-
-    with gr.Row():
-        include_patterns_textbox = gr.Textbox(
-            label="Include URL Patterns (one per line, regex compatible)",
-            placeholder="""e.g., /blog/.*
-example.com/articles/.*""",
-            lines=3,
-            elem_id="crawler_include_patterns",
-            scale=1,
-        )
-        ui_components.append(include_patterns_textbox)
-
-        exclude_patterns_textbox = gr.Textbox(
-            label="Exclude URL Patterns (one per line, regex compatible)",
-            placeholder="""e.g., /category/.*
-.*/login""",
-            lines=3,
-            elem_id="crawler_exclude_patterns",
-            scale=1,
-        )
-        ui_components.append(exclude_patterns_textbox)
-
-    with gr.Accordion(
-        "Sitemap Options", open=False, elem_id="crawler_sitemap_options_accordion"
-    ):
-        use_sitemap_checkbox = gr.Checkbox(
-            label="Use Sitemap?",
-            value=False,
-            elem_id="crawler_use_sitemap_checkbox",
-        )
-        # ui_components.append(use_sitemap_checkbox) # Appended later with its group
-
-        sitemap_url_textbox = gr.Textbox(
-            label="Sitemap URL (e.g., /sitemap.xml or full URL)",
-            placeholder="Enter sitemap URL relative to start URL or full path",
-            visible=False,
-            elem_id="crawler_sitemap_url_textbox",
-        )
-        # ui_components.append(sitemap_url_textbox) # Appended later with its group
-
-        use_sitemap_checkbox.change(
-            fn=lambda x: gr.update(visible=x),
-            inputs=[use_sitemap_checkbox],
-            outputs=[sitemap_url_textbox],
-        )
-    # Add sitemap components to the main list for return
-    # sitemap_elements_for_return = [use_sitemap_checkbox, sitemap_url_textbox] # Unused variable
-
-    with gr.Accordion(
-        "Advanced Prompt Options",
-        open=False,
-        elem_id="crawler_advanced_options_accordion",
-    ):  # Removed assignment to advanced_options_accordion_component
-        custom_system_prompt = gr.Textbox(
-            label="Custom System Prompt (Optional)",
-            placeholder="Leave empty to use the default system prompt for card generation.",
-            lines=5,
-            info="Define the overall role and instructions for the AI.",
-            elem_id="crawler_custom_system_prompt",
-        )
-        # ui_components.append(custom_system_prompt) # Appended later
-
-        custom_user_prompt_template = gr.Textbox(
-            label="Custom User Prompt Template (Optional)",
-            placeholder="Leave empty to use default. Available placeholders: {url}, {content}",
-            lines=5,
-            info="Define how the page URL and content are presented to the AI.",
-            elem_id="crawler_custom_user_prompt_template",
-        )
-        # ui_components.append(custom_user_prompt_template) # Appended later
-    # Add prompt components to the main list for return
-    # prompt_elements_for_return = [custom_system_prompt, custom_user_prompt_template] # Unused variable
-
-    # Crawl button (will trigger crawl_and_generate, results populate main DataFrame)
-    crawl_button = gr.Button(
-        "Crawl Content & Prepare Cards",  # Changed button text
-        variant="secondary",  # Differentiate from main generate button
-        elem_id="crawler_crawl_content_button",
-    )
-    # ui_components.append(crawl_button) # Returned separately
-
-    # Progress bar and status for the crawling process
-    progress_bar = (
-        gr.Progress()
-    )  # Removed elem_id as gr.Progress might not support it directly
-    progress_status_textbox = gr.Textbox(
-        label="Crawl Status",
-        interactive=False,
-        lines=3,  # Reduced lines
-        placeholder="Crawling process status will appear here...",
-        elem_id="crawler_status_textbox",
-    )
-    # ui_components.append(progress_status_textbox) # Returned separately
-
-    # REMOVED UI elements:
-    # - export_format_radio (no longer needed here)
-    # - All preview related: preview_row_component, preview_dataframe_component, update_cards_button_component
-    # - All preview export related: export_format_preview_component, deck_name_preview_component, export_button_preview_component
-    # - All direct file download related: download_row_group, generated_file_output, download_button
-
-    # The main ui_components list should contain all elements whose values are needed as inputs to the crawl/generation
-    # or whose visibility might be managed together.
-    # For clarity, specific components like buttons or progress bars are returned separately if they have specific event handlers
-    # or are managed distinctly.
-
-    # Add all input fields to ui_components for easier management if needed, or return them individually.
-    # For now, returning them grouped for clarity.
-
-    return (
-        ui_components,
-        crawl_button,
-        progress_bar,
-        progress_status_textbox,
-        custom_system_prompt,
-        custom_user_prompt_template,
-        use_sitemap_checkbox,
-        sitemap_url_textbox,
-    )
-
-
-# --- Crawl and Generate Logic (Task 7) ---
-
-# MODIFIED: Get model values from AVAILABLE_MODELS for validation
-CRAWLER_AVAILABLE_MODELS_VALUES = [m["value"] for m in AVAILABLE_MODELS]
-
-
-def _basic_sanitize_filename(name: str) -> str:
-    """Basic filename sanitization by replacing non-alphanumeric characters with underscores."""
-    return re.sub(r"[^a-zA-Z0-9_.-]", "_", name)
 
 
-def _validate_crawl_url(url: str) -> bool:
-    """Validate URL for crawling."""
-    if not url or not url.startswith(("http://", "https://")):
-        gr.Warning("Invalid URL provided. Please enter a valid http/https URL.")
-        return False
-    try:
-        urlparse(url)
-        return True
-    except Exception:
-        return False
-
-
-def _create_web_crawler(
-    url: str,
-    max_depth: int,
-    include_patterns: str,
-    exclude_patterns: str,
-    use_sitemap: bool,
-    sitemap_url_str: str,
-) -> WebCrawler:
-    """Create configured WebCrawler instance."""
-    include_list = [p.strip() for p in include_patterns.split(",") if p.strip()]
-    exclude_list = [p.strip() for p in exclude_patterns.split(",") if p.strip()]
-
-    return WebCrawler(
-        start_url=url,
-        max_depth=max_depth,
-        include_patterns=include_list,
-        exclude_patterns=exclude_list,
-        use_sitemap=use_sitemap,
-        sitemap_url=sitemap_url_str
-        if use_sitemap and sitemap_url_str.strip()
-        else None,
-    )
-
-
-def _create_crawl_progress_callback(
-    progress: gr.Progress,
-) -> Tuple[Callable[[int, int, str], None], List[int]]:
-    """Create progress callback for crawler with mutable state container."""
-    total_urls_container = [0]  # Mutable container for nonlocal-like behavior
-
-    def callback(processed_count: int, total_urls: int, current_url: str):
-        total_urls_container[0] = total_urls
-        if total_urls_container[0] > 0:
-            progress(
-                0.1 + (processed_count / total_urls_container[0]) * 0.4,
-                desc=f"Crawling: {processed_count}/{total_urls_container[0]} URLs. Current: {current_url}",
-            )
-        else:
-            progress(
-                0.1 + processed_count * 0.01,
-                desc=f"Crawling: {processed_count} URLs discovered. Current: {current_url}",
-            )
-
-    return callback, total_urls_container
-
-
-async def _perform_web_crawl(
-    crawler: WebCrawler,
-    progress: gr.Progress,
-    url: str,
-) -> Optional[List[CrawledPage]]:
-    """Execute web crawl and return pages or None if empty."""
-    callback, _ = _create_crawl_progress_callback(progress)
-
-    crawler_ui_logger.info(f"Starting crawl for {url}...")
-    progress(0.15, desc=f"Starting crawl for {url}...")
-
-    crawled_pages = await asyncio.to_thread(crawler.crawl, progress_callback=callback)
-
-    crawler_ui_logger.info(f"Crawling finished. Found {len(crawled_pages)} pages.")
-    progress(0.5, desc=f"Crawling finished. Found {len(crawled_pages)} pages.")
-
-    return crawled_pages if crawled_pages else None
-
-
-async def _process_crawled_with_agents(
-    crawled_pages: List[CrawledPage],
-    client_manager: OpenAIClientManager,
-    url: str,
-    progress: gr.Progress,
-) -> Tuple[List[Card], str]:
-    """Process crawled content with agent system."""
-    crawler_ui_logger.info("Using agent system for web crawling card generation")
-
-    orchestrator = AgentOrchestrator(client_manager)
-    # API key is already configured in client_manager, pass empty string as placeholder
-    await orchestrator.initialize("")
-
-    combined_content = "\n\n--- PAGE BREAK ---\n\n".join(
-        [
-            f"URL: {page.url}\nTitle: {page.title}\nContent: {page.text_content[:2000]}..."
-            for page in crawled_pages[:10]
-        ]
-    )
-
-    context = {
-        "source_text": combined_content,
-        "crawl_source": url,
-        "pages_crawled": len(crawled_pages),
-    }
-
-    progress(0.6, desc="Processing with agent system...")
-
-    agent_cards, _ = await orchestrator.generate_cards_with_agents(
-        topic=f"Content from {url}",
-        subject="web_content",
-        num_cards=min(len(crawled_pages) * 3, 50),
-        difficulty="intermediate",
-        enable_quality_pipeline=True,
-        context=context,
-    )
-
-    if agent_cards:
-        progress(0.9, desc=f"Agent system generated {len(agent_cards)} cards")
-        final_message = (
-            f"Agent system processed content from {len(crawled_pages)} pages. "
-            f"Generated {len(agent_cards)} high-quality cards."
-        )
-    else:
-        final_message = "Agent system returned no cards"
-
-    return agent_cards or [], final_message
-
-
-async def crawl_and_generate(
-    url: str,
-    max_depth: int,
-    crawler_requests_per_second: float,
-    include_patterns: str,
-    exclude_patterns: str,
-    model: str,
-    export_format_ui: str,
-    custom_system_prompt: str,
-    custom_user_prompt_template: str,
-    use_sitemap: bool,
-    sitemap_url_str: str,
-    client_manager: OpenAIClientManager,
-    progress: gr.Progress,
-    status_textbox: gr.Textbox,
-) -> Tuple[str, List[dict], List[Card]]:
-    """Crawls a website, generates Anki cards, and prepares them for export/display."""
-    crawler_ui_logger.info(f"Crawl and generate called for URL: {url}")
-
-    if not _validate_crawl_url(url):
-        return "Invalid URL", [], []
-
-    try:
-        crawler = _create_web_crawler(
-            url,
-            max_depth,
-            include_patterns,
-            exclude_patterns,
-            use_sitemap,
-            sitemap_url_str,
-        )
-
-        crawled_pages = await _perform_web_crawl(crawler, progress, url)
-        if not crawled_pages:
-            progress(1.0, desc="No pages were crawled. Check URL and patterns.")
-            return (
-                "No pages were crawled. Check URL and patterns.",
-                pd.DataFrame().to_dict(orient="records"),
-                [],
-            )
-
-        agent_cards, final_message = await _process_crawled_with_agents(
-            crawled_pages,
-            client_manager,
-            url,
-            progress,
-        )
-
-        if agent_cards:
-            cards_for_dataframe_export = generate_cards_from_crawled_content(
-                agent_cards
-            )
-            progress(1.0, desc=final_message)
-            return final_message, cards_for_dataframe_export, agent_cards
-        else:
-            progress(1.0, desc=final_message)
-            return final_message, pd.DataFrame().to_dict(orient="records"), []
-
-    except ConnectionError as e:
-        crawler_ui_logger.error(f"Connection error during crawl: {e}", exc_info=True)
-        progress(1.0, desc=f"Connection error: {e}")
-        return f"Connection error: {e}", pd.DataFrame().to_dict(orient="records"), []
-    except ValueError as e:
-        crawler_ui_logger.error(f"Value error: {e}", exc_info=True)
-        progress(1.0, desc=f"Input error: {e}")
-        return f"Input error: {e}", pd.DataFrame().to_dict(orient="records"), []
-    except RuntimeError as e:  # Catch RuntimeError from client_manager.get_client()
-        crawler_ui_logger.error(
-            f"Runtime error (e.g., OpenAI client not init): {e}", exc_info=True
-        )
-        progress(1.0, desc=f"Runtime error: {e}")
-        return f"Runtime error: {e}", pd.DataFrame().to_dict(orient="records"), []
-    except Exception as e:
-        crawler_ui_logger.error(
-            f"Unexpected error in crawl_and_generate: {e}", exc_info=True
-        )
-        progress(1.0, desc=f"Unexpected error: {e}")
-        return (
-            f"An unexpected error occurred: {e}",
-            pd.DataFrame().to_dict(orient="records"),
-            [],
-        )
-
-
-# --- Card Preview and Editing Utilities (Task 13.3) ---
+# --- Card Preview and Editing Utilities ---
 
 
 def cards_to_dataframe(cards: List[Card]) -> pd.DataFrame:
@@ -509,16 +61,16 @@ def cards_to_dataframe(cards: List[Card]) -> pd.DataFrame:
         data_for_df.append(
             {
                 "ID": i + 1,  # 1-indexed ID for display
-                "Topic": topic_str,  # Added Topic
+                "Topic": topic_str,
                 "Front": card.front.question,
                 "Back": card.back.answer,
                 "Tags": tags_str,
-                "Card Type": card.card_type or "Basic",  # Mapped from note_type
-                "Explanation": card.back.explanation or "",  # Added Explanation
-                "Example": card.back.example or "",  # Added Example
+                "Card Type": card.card_type or "Basic",
+                "Explanation": card.back.explanation or "",
+                "Example": card.back.example or "",
                 "Source_URL": card.metadata.get("source_url", "")
                 if card.metadata
-                else "",  # Added Source URL
+                else "",
             }
         )
     # Define all columns explicitly for consistent DataFrame structure
@@ -546,7 +98,7 @@ def dataframe_to_cards(df: pd.DataFrame, original_cards: List[Card]) -> List[Car
     if df.empty and not original_cards:
         return []
     if df.empty and original_cards:
-        return []  # Or original_cards if no change is intended on empty df
+        return []
 
     for index, row in df.iterrows():
         try:
@@ -556,8 +108,6 @@ def dataframe_to_cards(df: pd.DataFrame, original_cards: List[Card]) -> List[Car
             if 0 <= original_card_index < len(original_cards):
                 card_to_update = original_cards[original_card_index]
 
-                # Create new CardFront and CardBack objects for immutability if preferred,
-                # or update existing ones since Pydantic models are mutable.
                 new_front = card_to_update.front.copy(
                     update={
                         "question": str(row.get("Front", card_to_update.front.question))
@@ -592,7 +142,6 @@ def dataframe_to_cards(df: pd.DataFrame, original_cards: List[Card]) -> List[Car
                 new_metadata["topic"] = str(
                     row.get("Topic", new_metadata.get("topic", "N/A"))
                 )
-                # Source URL is generally not editable from this simple table
 
                 updated_card = card_to_update.copy(
                     update={
@@ -606,16 +155,14 @@ def dataframe_to_cards(df: pd.DataFrame, original_cards: List[Card]) -> List[Car
                 )
                 updated_cards.append(updated_card)
             else:
-                crawler_ui_logger.warning(
+                logger.warning(
                     f"Card ID {card_id} from DataFrame is out of bounds for original_cards list."
                 )
         except (ValueError, KeyError, AttributeError) as e:
-            crawler_ui_logger.error(
+            logger.error(
                 f"Error processing row {index} from DataFrame: {row}. Error: {e}"
             )
             if 0 <= original_card_index < len(original_cards):
-                updated_cards.append(
-                    original_cards[original_card_index]
-                )  # Re-add original on error
+                updated_cards.append(original_cards[original_card_index])
             continue
     return updated_cards

app.py

@@ -18,11 +18,7 @@ from ankigen_core.exporters import (
 from ankigen_core.llm_interface import (
     OpenAIClientManager,
 )  # structured_output_completion is internal to core modules
-from ankigen_core.ui_logic import (
-    crawl_and_generate,
-    create_crawler_main_mode_elements,
-    update_mode_visibility,
-)
+from ankigen_core.ui_logic import update_mode_visibility
 from ankigen_core.utils import (
     ResponseCache,
     get_logger,
@@ -159,13 +155,11 @@ def create_ankigen_interface():
                         generation_mode = gr.Radio(
                             choices=[
                                 ("Single Subject", "subject"),
-                                ("Learning Path", "path"),
-                                ("From Text", "text"),
-                                ("From Web", "web"),
                             ],
                             value="subject",
                             label="Generation Mode",
                             info="Choose how you want to generate content",
+                            visible=False,  # Hidden since only one mode exists
                         )
                         with gr.Group() as subject_mode:
                             subject = gr.Textbox(
@@ -176,41 +170,6 @@ def create_ankigen_interface():
                                 "Auto-fill",
                                 variant="secondary",
                             )
-                        with gr.Group(visible=False) as text_mode:
-                            source_text = gr.Textbox(
-                                label="Source Text",
-                                placeholder="Paste text here...",
-                                lines=15,
-                            )
-                        with gr.Group(visible=False) as web_mode:
-                            # --- BEGIN INTEGRATED CRAWLER UI (Task 16) ---
-                            logger.info(
-                                "Setting up integrated Web Crawler UI elements...",
-                            )
-                            (
-                                crawler_input_ui_elements,  # List of inputs like URL, depth, model, patterns
-                                web_crawl_button,  # Specific button to trigger crawl
-                                web_crawl_progress_bar,
-                                web_crawl_status_textbox,
-                                web_crawl_custom_system_prompt,
-                                web_crawl_custom_user_prompt_template,
-                                web_crawl_use_sitemap_checkbox,
-                                web_crawl_sitemap_url_textbox,
-                            ) = create_crawler_main_mode_elements()
-
-                            # Unpack crawler_input_ui_elements for clarity and use
-                            web_crawl_url_input = crawler_input_ui_elements[0]
-                            web_crawl_max_depth_slider = crawler_input_ui_elements[1]
-                            web_crawl_req_per_sec_slider = crawler_input_ui_elements[2]
-                            web_crawl_model_dropdown = crawler_input_ui_elements[3]
-                            web_crawl_include_patterns_textbox = (
-                                crawler_input_ui_elements[4]
-                            )
-                            web_crawl_exclude_patterns_textbox = (
-                                crawler_input_ui_elements[5]
-                            )
-                            # --- END INTEGRATED CRAWLER UI ---
-
                         api_key_input = gr.Textbox(
                             label="OpenAI API Key",
                             type="password",
@@ -364,29 +323,21 @@ def create_ankigen_interface():
                 inputs=[
                     generation_mode,
                     subject,
-                    source_text,
-                    web_crawl_url_input,
                 ],
                 outputs=[
                     subject_mode,
-                    text_mode,
-                    web_mode,
                     cards_output,
                     subject,
-                    source_text,
-                    web_crawl_url_input,
                     output,
                     total_cards_html,
                 ],
             )
 
-            # Define an async wrapper for the orchestrate_card_generation partial
+            # Define an async wrapper for the orchestrate_card_generation
             async def handle_generate_click(
                 api_key_input_val,
                 subject_val,
                 generation_mode_val,
-                source_text_val,
-                url_input_val,
                 model_choice_val,
                 topic_number_val,
                 cards_per_topic_val,
@@ -394,20 +345,16 @@ def create_ankigen_interface():
                 generate_cloze_checkbox_val,
                 library_name_val,
                 library_topic_val,
-                progress=gr.Progress(track_tqdm=True),  # Added progress tracker
+                progress=gr.Progress(track_tqdm=True),
             ):
-                # Recreate the partial function call, but now it can be awaited
-                # The actual orchestrate_card_generation is already partially applied with client_manager and response_cache
-                # So, we need to get that specific partial object if it's stored, or redefine the partial logic here.
-                # For simplicity and clarity, let's assume direct call to orchestrate_card_generation directly here
                 return await orchestrate_card_generation(
-                    client_manager,  # from global scope
-                    response_cache,  # from global scope
+                    client_manager,
+                    response_cache,
                     api_key_input_val,
                     subject_val,
                     generation_mode_val,
-                    source_text_val,
-                    url_input_val,
+                    "",  # source_text - deprecated
+                    "",  # url_input - deprecated
                     model_choice_val,
                     topic_number_val,
                     cards_per_topic_val,
@@ -416,16 +363,13 @@ def create_ankigen_interface():
                     library_name=library_name_val if library_name_val else None,
                     library_topic=library_topic_val if library_topic_val else None,
                 )
-                # Expect 3-tuple return (dataframe, total_cards_html, token_usage_html)
 
             generate_button.click(
-                fn=handle_generate_click,  # MODIFIED: Use the new async handler
+                fn=handle_generate_click,
                 inputs=[
                     api_key_input,
                     subject,
                     generation_mode,
-                    source_text,
-                    web_crawl_url_input,
                     model_choice,
                     topic_number,
                     cards_per_topic,
@@ -629,150 +573,8 @@ def create_ankigen_interface():
                     preference_prompt,
                     generate_cloze_checkbox,
                     model_choice,
-                    library_accordion,  # Reference to the accordion component
-                ],
-            )
-
-            async def handle_web_crawl_click(
-                api_key_val: str,
-                url: str,
-                max_depth: int,
-                req_per_sec: float,
-                model: str,  # This is the model for LLM processing of crawled content
-                include_patterns: str,
-                exclude_patterns: str,
-                custom_system_prompt: str,
-                custom_user_prompt_template: str,
-                use_sitemap: bool,
-                sitemap_url: str,
-                progress=gr.Progress(track_tqdm=True),
-            ):
-                progress(0, desc="Initializing web crawl...")
-                yield {
-                    web_crawl_status_textbox: gr.update(
-                        value="Initializing web crawl...",
-                    ),
-                    output: gr.update(value=None),  # Clear main output table
-                    total_cards_html: gr.update(
-                        visible=False,
-                        value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                    ),
-                }
-
-                if not api_key_val:
-                    logger.error("API Key is missing for web crawler operation.")
-                    yield {
-                        web_crawl_status_textbox: gr.update(
-                            value="Error: OpenAI API Key is required.",
-                        ),
-                    }
-                    return
-                try:
-                    await client_manager.initialize_client(api_key_val)
-                except Exception as e:
-                    logger.error(
-                        f"Failed to initialize OpenAI client for crawler: {e}",
-                        exc_info=True,
-                    )
-                    yield {
-                        web_crawl_status_textbox: gr.update(
-                            value=f"Error: Client init failed: {e!s}",
-                        ),
-                    }
-                    return
-
-                message, cards_list_of_dicts, _ = await crawl_and_generate(
-                    url=url,
-                    max_depth=max_depth,
-                    crawler_requests_per_second=req_per_sec,
-                    include_patterns=include_patterns,
-                    exclude_patterns=exclude_patterns,
-                    model=model,
-                    export_format_ui="",  # No longer used for direct export from crawl_and_generate
-                    custom_system_prompt=custom_system_prompt,
-                    custom_user_prompt_template=custom_user_prompt_template,
-                    use_sitemap=use_sitemap,
-                    sitemap_url_str=sitemap_url,
-                    client_manager=client_manager,  # Passed from global scope
-                    progress=progress,  # Gradio progress object
-                    status_textbox=web_crawl_status_textbox,  # Specific status textbox for crawl
-                )
-
-                if cards_list_of_dicts:
-                    try:
-                        # Convert List[Dict] to Pandas DataFrame for the main output component
-                        preview_df_value = pd.DataFrame(cards_list_of_dicts)
-                        # Ensure columns match the main output dataframe
-                        # The `generate_cards_from_crawled_content` which produces `cards_list_of_dicts`
-                        # should already format it correctly. If not, mapping is needed here.
-                        # For now, assume it matches the main table structure expected by `gr.Dataframe(value=example_data)`
-
-                        # Check if columns match example_data, if not, reorder/rename or log warning
-                        if not preview_df_value.empty:
-                            expected_cols = example_data.columns.tolist()
-                            # Basic check, might need more robust mapping if structures differ significantly
-                            if not all(
-                                col in preview_df_value.columns for col in expected_cols
-                            ):
-                                logger.warning(
-                                    "Crawled card data columns mismatch main output, attempting to use available data.",
-                                )
-                                # Potentially select only common columns or reindex if necessary
-                                # For now, we'll pass it as is, Gradio might handle extra/missing cols gracefully or error.
-
-                        num_cards = len(preview_df_value)
-                        total_cards_update = f"<div><b>Total Cards Prepared from Crawl:</b> <span id='total-cards-count'>{num_cards}</span></div>"
-
-                        yield {
-                            web_crawl_status_textbox: gr.update(value=message),
-                            output: gr.update(value=preview_df_value),
-                            total_cards_html: gr.update(
-                                visible=True,
-                                value=total_cards_update,
-                            ),
-                        }
-                    except Exception as e:
-                        logger.error(
-                            f"Error converting crawled cards to DataFrame: {e}",
-                            exc_info=True,
-                        )
-                        yield {
-                            web_crawl_status_textbox: gr.update(
-                                value=f"{message} (Error displaying cards: {e!s})",
-                            ),
-                            output: gr.update(value=None),
-                            total_cards_html: gr.update(visible=False),
-                        }
-                else:
-                    yield {
-                        web_crawl_status_textbox: gr.update(
-                            value=message,
-                        ),  # Message from crawl_and_generate (e.g. no cards)
-                        output: gr.update(value=None),
-                        total_cards_html: gr.update(visible=False),
-                    }
-
-            web_crawl_button.click(
-                fn=handle_web_crawl_click,
-                inputs=[
-                    api_key_input,
-                    web_crawl_url_input,
-                    web_crawl_max_depth_slider,
-                    web_crawl_req_per_sec_slider,
-                    web_crawl_model_dropdown,  # Model for LLM processing of content
-                    web_crawl_include_patterns_textbox,
-                    web_crawl_exclude_patterns_textbox,
-                    web_crawl_custom_system_prompt,
-                    web_crawl_custom_user_prompt_template,
-                    web_crawl_use_sitemap_checkbox,
-                    web_crawl_sitemap_url_textbox,
-                ],
-                outputs=[
-                    web_crawl_status_textbox,  # Specific status for crawl
-                    output,  # Main output DataFrame
-                    total_cards_html,  # Main total cards display
+                    library_accordion,
                 ],
-                # Removed progress_bar from outputs as it's handled by gr.Progress(track_tqdm=True)
             )
 
     logger.info("AnkiGen Gradio interface creation complete.")