Add 'See the Code' feature and large file size warning

- Add collapsible "See the Code" accordions for Extract and Classify tasks
- Generate reproducible Python code snippets for all operations
- Add file size check (>100MB) for images/PDFs with warning
- When large files detected, show warning and generated code as alternative
- Users can copy code to run locally with: pip install cat-llm

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -21,6 +21,167 @@ except ImportError as e:
 
 MAX_CATEGORIES = 10
 INITIAL_CATEGORIES = 3
+MAX_FILE_SIZE_MB = 100  # Warn users if total file size exceeds this
+
+
+def calculate_total_file_size(files):
+    """Calculate total size of uploaded files in MB."""
+    if files is None:
+        return 0
+    if not isinstance(files, list):
+        files = [files]
+
+    total_bytes = 0
+    for f in files:
+        try:
+            file_path = f if isinstance(f, str) else f.name
+            total_bytes += os.path.getsize(file_path)
+        except (OSError, AttributeError):
+            pass
+    return total_bytes / (1024 * 1024)  # Convert to MB
+
+
+def generate_extract_code(input_type, description, model, model_source, max_categories, mode=None):
+    """Generate Python code for category extraction."""
+    if input_type == "text":
+        return f'''import catllm
+import pandas as pd
+
+# Load your data
+df = pd.read_csv("your_data.csv")
+
+# Extract categories from the text column
+result = catllm.extract(
+    input_data=df["{description}"].tolist(),
+    api_key="YOUR_API_KEY",
+    input_type="text",
+    description="{description}",
+    user_model="{model}",
+    model_source="{model_source}",
+    max_categories={max_categories}
+)
+
+# View extracted categories
+print(result["top_categories"])
+print(result["counts_df"])
+'''
+    elif input_type == "pdf":
+        mode_line = f',\n    mode="{mode}"' if mode else ''
+        return f'''import catllm
+
+# Extract categories from PDF documents
+result = catllm.extract(
+    input_data="path/to/your/pdfs/",  # or list of PDF paths
+    api_key="YOUR_API_KEY",
+    input_type="pdf",
+    description="{description}"{mode_line},
+    user_model="{model}",
+    model_source="{model_source}",
+    max_categories={max_categories}
+)
+
+# View extracted categories
+print(result["top_categories"])
+print(result["counts_df"])
+'''
+    else:  # image
+        return f'''import catllm
+
+# Extract categories from images
+result = catllm.extract(
+    input_data="path/to/your/images/",  # or list of image paths
+    api_key="YOUR_API_KEY",
+    input_type="image",
+    description="{description}",
+    user_model="{model}",
+    model_source="{model_source}",
+    max_categories={max_categories}
+)
+
+# View extracted categories
+print(result["top_categories"])
+print(result["counts_df"])
+'''
+
+
+def generate_classify_code(input_type, description, categories, model, model_source, mode=None):
+    """Generate Python code for classification."""
+    categories_str = ",\n    ".join([f'"{cat}"' for cat in categories])
+
+    if input_type == "text":
+        return f'''import catllm
+import pandas as pd
+
+# Load your data
+df = pd.read_csv("your_data.csv")
+
+# Define categories
+categories = [
+    {categories_str}
+]
+
+# Classify the text data
+result = catllm.classify(
+    input_data=df["{description}"].tolist(),
+    categories=categories,
+    api_key="YOUR_API_KEY",
+    input_type="text",
+    description="{description}",
+    user_model="{model}",
+    model_source="{model_source}"
+)
+
+# View results
+print(result)
+result.to_csv("classified_results.csv", index=False)
+'''
+    elif input_type == "pdf":
+        mode_line = f',\n    mode="{mode}"' if mode else ''
+        return f'''import catllm
+
+# Define categories
+categories = [
+    {categories_str}
+]
+
+# Classify PDF documents
+result = catllm.classify(
+    input_data="path/to/your/pdfs/",  # or list of PDF paths
+    categories=categories,
+    api_key="YOUR_API_KEY",
+    input_type="pdf",
+    description="{description}"{mode_line},
+    user_model="{model}",
+    model_source="{model_source}"
+)
+
+# View results
+print(result)
+result.to_csv("classified_results.csv", index=False)
+'''
+    else:  # image
+        return f'''import catllm
+
+# Define categories
+categories = [
+    {categories_str}
+]
+
+# Classify images
+result = catllm.classify(
+    input_data="path/to/your/images/",  # or list of image paths
+    categories=categories,
+    api_key="YOUR_API_KEY",
+    input_type="image",
+    description="{description}",
+    user_model="{model}",
+    model_source="{model_source}"
+)
+
+# View results
+print(result)
+result.to_csv("classified_results.csv", index=False)
+'''
 
 # Free models (uses Space secrets - no user API key needed)
 FREE_MODEL_CHOICES = [
@@ -497,12 +658,12 @@ def run_extract_categories(input_type, spreadsheet_file, spreadsheet_column,
                            progress=gr.Progress(track_tqdm=True)):
     """Extract categories from data and display them in a table."""
     if not CATLLM_AVAILABLE:
-        yield None, None, "**Error:** catllm package not available"
+        yield None, None, None, "**Error:** catllm package not available"
         return
 
     actual_api_key, provider = get_api_key(model, model_tier, api_key_input)
     if not actual_api_key:
-        yield None, None, f"**Error:** {provider} API key not configured"
+        yield None, None, None, f"**Error:** {provider} API key not configured"
         return
 
     if model_source_input == "auto":
@@ -510,17 +671,48 @@ def run_extract_categories(input_type, spreadsheet_file, spreadsheet_column,
     else:
         model_source = model_source_input
 
+    # Check file size for images and PDFs
+    files_to_check = None
+    if input_type == "Images":
+        files_to_check = image_folder if image_folder else image_file
+    elif input_type == "PDF Documents":
+        files_to_check = pdf_folder if pdf_folder else pdf_file
+
+    if files_to_check:
+        total_size_mb = calculate_total_file_size(files_to_check)
+        if total_size_mb > MAX_FILE_SIZE_MB:
+            # Generate the code for the user
+            if input_type == "Images":
+                code = generate_extract_code("image", image_description or "images", model, model_source, int(max_categories_val))
+            else:
+                mode_mapping = {"Image (visual documents)": "image", "Text (text-heavy)": "text", "Both (comprehensive)": "both"}
+                actual_mode = mode_mapping.get(pdf_mode, "image")
+                code = generate_extract_code("pdf", pdf_description or "document", model, model_source, int(max_categories_val), actual_mode)
+
+            warning_msg = f"""**⚠️ Large Upload Detected ({total_size_mb:.1f} MB)**
+
+Uploads over {MAX_FILE_SIZE_MB} MB may experience performance issues or timeouts on this web app.
+
+**Recommended:** Run the code locally using the Python package instead. See the code below, or click "See the Code" after this message.
+
+```
+pip install cat-llm
+```
+"""
+            yield None, None, code, warning_msg
+            return
+
     try:
-        yield None, None, "Extracting categories from your data..."
+        yield None, None, None, "Extracting categories from your data..."
 
         start_time = time.time()
 
         if input_type == "Survey Responses":
             if not spreadsheet_file:
-                yield None, None, "**Error:** Please upload a CSV/Excel file"
+                yield None, None, None, "**Error:** Please upload a CSV/Excel file"
                 return
             if not spreadsheet_column:
-                yield None, None, "**Error:** Please select a column"
+                yield None, None, None, "**Error:** Please select a column"
                 return
 
             file_path = spreadsheet_file if isinstance(spreadsheet_file, str) else spreadsheet_file.name
@@ -554,7 +746,7 @@ def run_extract_categories(input_type, spreadsheet_file, spreadsheet_column,
                 else:
                     pdf_input = pdf_file if isinstance(pdf_file, str) else pdf_file.name
             else:
-                yield None, None, "**Error:** Please upload PDF file(s) or a folder"
+                yield None, None, None, "**Error:** Please upload PDF file(s) or a folder"
                 return
 
             mode_mapping = {
@@ -593,7 +785,7 @@ def run_extract_categories(input_type, spreadsheet_file, spreadsheet_column,
                 else:
                     image_input = image_file if isinstance(image_file, str) else image_file.name
             else:
-                yield None, None, "**Error:** Please upload image file(s) or a folder"
+                yield None, None, None, "**Error:** Please upload image file(s) or a folder"
                 return
 
             # For images, use fewer divisions since each image can have multiple categories
@@ -614,7 +806,7 @@ def run_extract_categories(input_type, spreadsheet_file, spreadsheet_column,
             )
 
         else:
-            yield None, None, f"**Error:** Unknown input type: {input_type}"
+            yield None, None, None, f"**Error:** Unknown input type: {input_type}"
             return
 
         processing_time = time.time() - start_time
@@ -635,14 +827,25 @@ def run_extract_categories(input_type, spreadsheet_file, spreadsheet_column,
             categories_df.to_csv(f.name, index=False)
             csv_path = f.name
 
+        # Generate reproducibility code
+        if input_type == "Survey Responses":
+            code = generate_extract_code("text", spreadsheet_column, model, model_source, int(max_categories_val))
+        elif input_type == "PDF Documents":
+            mode_mapping = {"Image (visual documents)": "image", "Text (text-heavy)": "text", "Both (comprehensive)": "both"}
+            actual_mode = mode_mapping.get(pdf_mode, "image")
+            code = generate_extract_code("pdf", pdf_description or "document", model, model_source, int(max_categories_val), actual_mode)
+        else:  # Images
+            code = generate_extract_code("image", image_description or "images", model, model_source, int(max_categories_val))
+
         yield (
             gr.update(value=categories_df, visible=True),
             csv_path,
+            code,
             f"Extracted {len(top_categories)} categories in {processing_time:.1f}s"
         )
 
     except Exception as e:
-        yield None, None, f"**Error:** {str(e)}"
+        yield None, None, None, f"**Error:** {str(e)}"
 
 
 def run_classify_data(input_type, spreadsheet_file, spreadsheet_column,
@@ -653,19 +856,19 @@ def run_classify_data(input_type, spreadsheet_file, spreadsheet_column,
                       progress=gr.Progress(track_tqdm=True)):
     """Classify data with user-provided categories."""
     if not CATLLM_AVAILABLE:
-        yield None, None, None, None, "**Error:** catllm package not available"
+        yield None, None, None, None, None, "**Error:** catllm package not available"
         return
 
     all_cats = [cat1, cat2, cat3, cat4, cat5, cat6, cat7, cat8, cat9, cat10]
     categories = [c.strip() for c in all_cats if c and c.strip()]
 
     if not categories:
-        yield None, None, None, None, "**Error:** Please enter at least one category"
+        yield None, None, None, None, None, "**Error:** Please enter at least one category"
         return
 
     actual_api_key, provider = get_api_key(model, model_tier, api_key_input)
     if not actual_api_key:
-        yield None, None, None, None, f"**Error:** {provider} API key not configured"
+        yield None, None, None, None, None, f"**Error:** {provider} API key not configured"
         return
 
     if model_source_input == "auto":
@@ -673,17 +876,48 @@ def run_classify_data(input_type, spreadsheet_file, spreadsheet_column,
     else:
         model_source = model_source_input
 
+    # Check file size for images and PDFs
+    files_to_check = None
+    if input_type == "Images":
+        files_to_check = image_folder if image_folder else image_file
+    elif input_type == "PDF Documents":
+        files_to_check = pdf_folder if pdf_folder else pdf_file
+
+    if files_to_check:
+        total_size_mb = calculate_total_file_size(files_to_check)
+        if total_size_mb > MAX_FILE_SIZE_MB:
+            # Generate the code for the user
+            if input_type == "Images":
+                code = generate_classify_code("image", image_description or "images", categories, model, model_source)
+            else:
+                mode_mapping = {"Image (visual documents)": "image", "Text (text-heavy)": "text", "Both (comprehensive)": "both"}
+                actual_mode = mode_mapping.get(pdf_mode, "image")
+                code = generate_classify_code("pdf", pdf_description or "document", categories, model, model_source, actual_mode)
+
+            warning_msg = f"""**⚠️ Large Upload Detected ({total_size_mb:.1f} MB)**
+
+Uploads over {MAX_FILE_SIZE_MB} MB may experience performance issues or timeouts on this web app.
+
+**Recommended:** Run the code locally using the Python package instead. See the code below, or click "See the Code" after this message.
+
+```
+pip install cat-llm
+```
+"""
+            yield None, None, None, code, None, warning_msg
+            return
+
     try:
-        yield None, None, None, None, "Classifying your data..."
+        yield None, None, None, None, None, "Classifying your data..."
 
         start_time = time.time()
 
         if input_type == "Survey Responses":
             if not spreadsheet_file:
-                yield None, None, None, None, "**Error:** Please upload a CSV/Excel file"
+                yield None, None, None, None, None, "**Error:** Please upload a CSV/Excel file"
                 return
             if not spreadsheet_column:
-                yield None, None, None, None, "**Error:** Please select a column"
+                yield None, None, None, None, None, "**Error:** Please select a column"
                 return
 
             file_path = spreadsheet_file if isinstance(spreadsheet_file, str) else spreadsheet_file.name
@@ -723,7 +957,7 @@ def run_classify_data(input_type, spreadsheet_file, spreadsheet_column,
                     pdf_input = pdf_file if isinstance(pdf_file, str) else pdf_file.name
                     original_filename = pdf_input.split("/")[-1]
             else:
-                yield None, None, None, None, "**Error:** Please upload PDF file(s) or a folder"
+                yield None, None, None, None, None, "**Error:** Please upload PDF file(s) or a folder"
                 return
 
             column_name = "PDF Pages"
@@ -763,7 +997,7 @@ def run_classify_data(input_type, spreadsheet_file, spreadsheet_column,
                     image_input = image_file if isinstance(image_file, str) else image_file.name
                     original_filename = image_input.split("/")[-1]
             else:
-                yield None, None, None, None, "**Error:** Please upload image file(s) or a folder"
+                yield None, None, None, None, None, "**Error:** Please upload image file(s) or a folder"
                 return
 
             column_name = "Image Files"
@@ -779,7 +1013,7 @@ def run_classify_data(input_type, spreadsheet_file, spreadsheet_column,
             )
 
         else:
-            yield None, None, None, None, f"**Error:** Unknown input type: {input_type}"
+            yield None, None, None, None, None, f"**Error:** Unknown input type: {input_type}"
             return
 
         processing_time = time.time() - start_time
@@ -856,16 +1090,27 @@ Provide your work in JSON format where the number belonging to each category is
 
         plt.tight_layout()
 
+        # Generate reproducibility code
+        if input_type == "Survey Responses":
+            code = generate_classify_code("text", spreadsheet_column, categories, model, model_source)
+        elif input_type == "PDF Documents":
+            mode_mapping = {"Image (visual documents)": "image", "Text (text-heavy)": "text", "Both (comprehensive)": "both"}
+            actual_mode = mode_mapping.get(pdf_mode, "image")
+            code = generate_classify_code("pdf", pdf_description or "document", categories, model, model_source, actual_mode)
+        else:  # Images
+            code = generate_classify_code("image", image_description or "images", categories, model, model_source)
+
         yield (
             gr.update(value=fig, visible=True),
             gr.update(value=result, visible=True),
             [csv_path, report_pdf_path],
+            code,
             None,
             f"Classified {num_items} items in {processing_time:.1f}s"
         )
 
     except Exception as e:
-        yield None, None, None, None, f"**Error:** {str(e)}"
+        yield None, None, None, None, None, f"**Error:** {str(e)}"
 
 
 def run_extract_and_assign(input_type, spreadsheet_file, spreadsheet_column,
@@ -876,12 +1121,12 @@ def run_extract_and_assign(input_type, spreadsheet_file, spreadsheet_column,
                            progress=gr.Progress(track_tqdm=True)):
     """Extract categories then classify data with them."""
     if not CATLLM_AVAILABLE:
-        yield None, None, None, None, None, None, "**Error:** catllm package not available"
+        yield None, None, None, None, None, None, None, None, "**Error:** catllm package not available"
         return
 
     actual_api_key, provider = get_api_key(model, model_tier, api_key_input)
     if not actual_api_key:
-        yield None, None, None, None, None, None, f"**Error:** {provider} API key not configured"
+        yield None, None, None, None, None, None, None, None, f"**Error:** {provider} API key not configured"
         return
 
     if model_source_input == "auto":
@@ -889,18 +1134,49 @@ def run_extract_and_assign(input_type, spreadsheet_file, spreadsheet_column,
     else:
         model_source = model_source_input
 
+    # Check file size for images and PDFs
+    files_to_check = None
+    if input_type == "Images":
+        files_to_check = image_folder if image_folder else image_file
+    elif input_type == "PDF Documents":
+        files_to_check = pdf_folder if pdf_folder else pdf_file
+
+    if files_to_check:
+        total_size_mb = calculate_total_file_size(files_to_check)
+        if total_size_mb > MAX_FILE_SIZE_MB:
+            # Generate the code for the user
+            if input_type == "Images":
+                extract_code = generate_extract_code("image", image_description or "images", model, model_source, int(max_categories_val))
+            else:
+                mode_mapping = {"Image (visual documents)": "image", "Text (text-heavy)": "text", "Both (comprehensive)": "both"}
+                actual_mode = mode_mapping.get(pdf_mode, "image")
+                extract_code = generate_extract_code("pdf", pdf_description or "document", model, model_source, int(max_categories_val), actual_mode)
+
+            warning_msg = f"""**⚠️ Large Upload Detected ({total_size_mb:.1f} MB)**
+
+Uploads over {MAX_FILE_SIZE_MB} MB may experience performance issues or timeouts on this web app.
+
+**Recommended:** Run the code locally using the Python package instead. See the code below, or click "See the Code" after this message.
+
+```
+pip install cat-llm
+```
+"""
+            yield None, None, extract_code, None, None, None, None, None, warning_msg
+            return
+
     try:
         # Phase 1: Extract categories
-        yield None, None, None, None, None, None, "Phase 1: Extracting categories..."
+        yield None, None, None, None, None, None, None, None, "Phase 1: Extracting categories..."
 
         start_time = time.time()
 
         if input_type == "Survey Responses":
             if not spreadsheet_file:
-                yield None, None, None, None, None, None, "**Error:** Please upload a CSV/Excel file"
+                yield None, None, None, None, None, None, None, None, "**Error:** Please upload a CSV/Excel file"
                 return
             if not spreadsheet_column:
-                yield None, None, None, None, None, None, "**Error:** Please select a column"
+                yield None, None, None, None, None, None, None, None, "**Error:** Please select a column"
                 return
 
             file_path = spreadsheet_file if isinstance(spreadsheet_file, str) else spreadsheet_file.name
@@ -933,7 +1209,7 @@ def run_extract_and_assign(input_type, spreadsheet_file, spreadsheet_column,
                     input_data = pdf_file if isinstance(pdf_file, str) else pdf_file.name
                     original_filename = input_data.split("/")[-1]
             else:
-                yield None, None, None, None, None, None, "**Error:** Please upload PDF file(s) or a folder"
+                yield None, None, None, None, None, None, None, None, "**Error:** Please upload PDF file(s) or a folder"
                 return
 
             column_name = "PDF Pages"
@@ -964,7 +1240,7 @@ def run_extract_and_assign(input_type, spreadsheet_file, spreadsheet_column,
                     input_data = image_file if isinstance(image_file, str) else image_file.name
                     original_filename = input_data.split("/")[-1]
             else:
-                yield None, None, None, None, None, None, "**Error:** Please upload image file(s) or a folder"
+                yield None, None, None, None, None, None, None, None, "**Error:** Please upload image file(s) or a folder"
                 return
 
             column_name = "Image Files"
@@ -973,7 +1249,7 @@ def run_extract_and_assign(input_type, spreadsheet_file, spreadsheet_column,
             mode_param = None
 
         else:
-            yield None, None, None, None, None, None, f"**Error:** Unknown input type: {input_type}"
+            yield None, None, None, None, None, None, None, None, f"**Error:** Unknown input type: {input_type}"
             return
 
         # Calculate sensible divisions based on input size and type
@@ -1010,7 +1286,7 @@ def run_extract_and_assign(input_type, spreadsheet_file, spreadsheet_column,
         categories_df = extract_result.get('counts_df', pd.DataFrame())
 
         if not categories:
-            yield None, None, None, None, None, None, "**Error:** No categories were extracted"
+            yield None, None, None, None, None, None, None, None, "**Error:** No categories were extracted"
             return
 
         extract_time = time.time() - start_time
@@ -1026,10 +1302,14 @@ def run_extract_and_assign(input_type, spreadsheet_file, spreadsheet_column,
             categories_df.to_csv(f.name, index=False)
             extract_csv_path = f.name
 
+        # Generate extract code
+        extract_code = generate_extract_code(input_type_param, description, model, model_source, int(max_categories_val), mode_param)
+
         yield (
             gr.update(value=categories_df, visible=True),
             extract_csv_path,
-            None, None, None, None,
+            extract_code,
+            None, None, None, None, None,
             f"Extracted {len(categories)} categories in {extract_time:.1f}s. Now classifying..."
         )
 
@@ -1125,18 +1405,23 @@ Provide your work in JSON format where the number belonging to each category is
 
         plt.tight_layout()
 
+        # Generate classify code
+        classify_code = generate_classify_code(input_type_param, description, categories, model, model_source, mode_param)
+
         yield (
             gr.update(value=categories_df, visible=True),
             extract_csv_path,
+            extract_code,
             gr.update(value=fig, visible=True),
             gr.update(value=result, visible=True),
             [classify_csv_path, report_pdf_path],
+            classify_code,
             None,
             f"Extracted {len(categories)} categories and classified {num_items} items in {total_time:.1f}s"
         )
 
     except Exception as e:
-        yield None, None, None, None, None, None, f"**Error:** {str(e)}"
+        yield None, None, None, None, None, None, None, None, f"**Error:** {str(e)}"
 
 
 def add_category_field(current_count):
@@ -1190,10 +1475,12 @@ def reset_all():
         gr.update(visible=False),  # extract_output_group
         gr.update(value=None, visible=False),  # extracted_categories
         None,  # extract_download
+        "# Code will be generated after extraction",  # extract_code_display
         gr.update(visible=False),  # classify_output_group
         gr.update(value=None, visible=False),  # distribution_plot
         gr.update(value=None, visible=False),  # results
         None,  # download_file
+        "# Code will be generated after classification",  # classify_code_display
     ])
     return updates
 
@@ -1406,6 +1693,13 @@ Soria, C. (2025). CatLLM: A Python package for LLM-based text classification. DO
                     wrap=True
                 )
                 extract_download = gr.File(label="Download Categories (CSV)")
+                with gr.Accordion("See the Code", open=False):
+                    extract_code_display = gr.Code(
+                        label="Python Code",
+                        language="python",
+                        value="# Code will be generated after extraction",
+                        interactive=False
+                    )
 
             # Classify output group
             with gr.Group(visible=False) as classify_output_group:
@@ -1413,6 +1707,13 @@ Soria, C. (2025). CatLLM: A Python package for LLM-based text classification. DO
                 distribution_plot = gr.Plot(label="Category Distribution (%)", visible=False)
                 results = gr.DataFrame(label="Full Results", visible=False)
                 download_file = gr.File(label="Download Results (CSV + Methodology Report)", file_count="multiple")
+                with gr.Accordion("See the Code", open=False):
+                    classify_code_display = gr.Code(
+                        label="Python Code",
+                        language="python",
+                        value="# Code will be generated after classification",
+                        interactive=False
+                    )
 
     # Event handlers
     def switch_input_type(input_type_val):
@@ -1534,6 +1835,7 @@ Soria, C. (2025). CatLLM: A Python package for LLM-based text classification. DO
                      progress=gr.Progress(track_tqdm=True)):
         """Dispatch to appropriate function based on task mode."""
         if task == "extract":
+            # run_extract_categories yields: (categories_df, csv_path, code, status)
             for update in run_extract_categories(
                 input_type, spreadsheet_file, spreadsheet_column,
                 pdf_file, pdf_folder_val, pdf_description, pdf_mode,
@@ -1546,12 +1848,15 @@ Soria, C. (2025). CatLLM: A Python package for LLM-based text classification. DO
                 yield (
                     update[0],  # extracted_categories
                     update[1],  # extract_download
+                    update[2],  # extract_code_display
                     None,       # distribution_plot
                     None,       # results
                     None,       # download_file
-                    update[2]   # status
+                    None,       # classify_code_display
+                    update[3]   # status
                 )
         elif task == "assign":
+            # run_classify_data yields: (plot, df, files, code, unused, status)
             for update in run_classify_data(
                 input_type, spreadsheet_file, spreadsheet_column,
                 pdf_file, pdf_folder_val, pdf_description, pdf_mode,
@@ -1564,12 +1869,15 @@ Soria, C. (2025). CatLLM: A Python package for LLM-based text classification. DO
                 yield (
                     None,       # extracted_categories
                     None,       # extract_download
+                    None,       # extract_code_display
                     update[0],  # distribution_plot
                     update[1],  # results
                     update[2],  # download_file
-                    update[4]   # status
+                    update[3],  # classify_code_display
+                    update[5]   # status
                 )
         elif task == "extract_and_assign":
+            # run_extract_and_assign yields: (categories_df, extract_csv, extract_code, plot, df, files, classify_code, unused, status)
             for update in run_extract_and_assign(
                 input_type, spreadsheet_file, spreadsheet_column,
                 pdf_file, pdf_folder_val, pdf_description, pdf_mode,
@@ -1581,13 +1889,15 @@ Soria, C. (2025). CatLLM: A Python package for LLM-based text classification. DO
                 yield (
                     update[0],  # extracted_categories
                     update[1],  # extract_download
-                    update[2],  # distribution_plot
-                    update[3],  # results
-                    update[4],  # download_file
-                    update[6]   # status
+                    update[2],  # extract_code_display
+                    update[3],  # distribution_plot
+                    update[4],  # results
+                    update[5],  # download_file
+                    update[6],  # classify_code_display
+                    update[8]   # status
                 )
         else:
-            yield (None, None, None, None, None, "Please select a task first.")
+            yield (None, None, None, None, None, None, None, "Please select a task first.")
 
     run_btn.click(
         fn=dispatch_run,
@@ -1595,7 +1905,7 @@ Soria, C. (2025). CatLLM: A Python package for LLM-based text classification. DO
                 pdf_file, pdf_folder, pdf_description, pdf_mode,
                 image_file, image_folder, image_description,
                 max_categories] + category_inputs + [model_tier, model, model_source, api_key],
-        outputs=[extracted_categories, extract_download, distribution_plot, results, download_file, status]
+        outputs=[extracted_categories, extract_download, extract_code_display, distribution_plot, results, download_file, classify_code_display, status]
     )
 
     reset_btn.click(
@@ -1612,8 +1922,8 @@ Soria, C. (2025). CatLLM: A Python package for LLM-based text classification. DO
             categories_group, extract_settings_group, max_categories, model_group, run_btn,
             model_tier, model, model_source, api_key, api_key, api_key_status,
             status,
-            extract_output_group, extracted_categories, extract_download,
-            classify_output_group, distribution_plot, results, download_file
+            extract_output_group, extracted_categories, extract_download, extract_code_display,
+            classify_output_group, distribution_plot, results, download_file, classify_code_display
         ]
     )