Add progress bar with ETA for classification

app.py

@@ -890,35 +890,127 @@ with col_input:
             elif not categories_entered:
                 st.error("Please enter at least one category")
             else:
-                with st.spinner("Classifying data... This may take a few minutes."):
-                    mode = None
-                    if input_type_selected == "pdf":
-                        mode_mapping = {
-                            "Image (visual documents)": "image",
-                            "Text (text-heavy)": "text",
-                            "Both (comprehensive)": "both"
-                        }
-                        mode = mode_mapping.get(pdf_mode, "image")
-
-                    result_df, csv_path, pdf_path, code, status = run_classify_data(
-                        input_type_selected, input_data, description,
-                        categories_entered, model_tier, model, api_key, mode,
-                        original_filename, description
-                    )
+                # Set up progress tracking
+                mode = None
+                if input_type_selected == "pdf":
+                    mode_mapping = {
+                        "Image (visual documents)": "image",
+                        "Text (text-heavy)": "text",
+                        "Both (comprehensive)": "both"
+                    }
+                    mode = mode_mapping.get(pdf_mode, "image")
+
+                actual_api_key, provider = get_api_key(model, model_tier, api_key)
+                if not actual_api_key:
+                    st.error(f"{provider} API key not configured")
+                else:
+                    model_source = get_model_source(model)
+                    total_items = len(input_data) if isinstance(input_data, list) else 1
+
+                    # Progress UI
+                    progress_bar = st.progress(0)
+                    status_text = st.empty()
+
+                    all_results = []
+                    start_time = time.time()
+
+                    for i, item in enumerate(input_data if isinstance(input_data, list) else [input_data]):
+                        # Update progress
+                        progress = (i / total_items)
+                        progress_bar.progress(progress)
+
+                        # Calculate ETA
+                        elapsed = time.time() - start_time
+                        if i > 0:
+                            avg_time_per_item = elapsed / i
+                            remaining_items = total_items - i
+                            eta_seconds = avg_time_per_item * remaining_items
+                            eta_str = f" | ETA: {eta_seconds:.0f}s" if eta_seconds < 60 else f" | ETA: {eta_seconds/60:.1f}m"
+                        else:
+                            eta_str = ""
+
+                        status_text.text(f"Processing item {i+1} of {total_items} ({progress*100:.0f}%){eta_str}")
+
+                        try:
+                            classify_kwargs = {
+                                'input_data': [item],
+                                'categories': categories_entered,
+                                'api_key': actual_api_key,
+                                'input_type': input_type_selected,
+                                'description': description,
+                                'user_model': model,
+                                'model_source': model_source
+                            }
+                            if mode:
+                                classify_kwargs['mode'] = mode
+
+                            item_result = catllm.classify(**classify_kwargs)
+                            all_results.append(item_result)
+                        except Exception as e:
+                            st.warning(f"Error on item {i+1}: {str(e)}")
+                            continue
+
+                    # Complete progress
+                    progress_bar.progress(1.0)
+                    processing_time = time.time() - start_time
+                    status_text.text(f"Completed {total_items} items in {processing_time:.1f}s")
+
+                    if all_results:
+                        # Combine results
+                        result_df = pd.concat(all_results, ignore_index=True)
+
+                        # Save CSV
+                        with tempfile.NamedTemporaryFile(mode='w', suffix='_classified.csv', delete=False) as f:
+                            result_df.to_csv(f.name, index=False)
+                            csv_path = f.name
+
+                        # Calculate success rate
+                        if 'processing_status' in result_df.columns:
+                            success_count = (result_df['processing_status'] == 'success').sum()
+                            success_rate = (success_count / len(result_df)) * 100
+                        else:
+                            success_rate = 100.0
+
+                        # Get version info
+                        try:
+                            catllm_version = catllm.__version__
+                        except AttributeError:
+                            catllm_version = "unknown"
+                        python_version = sys.version.split()[0]
+
+                        # Generate methodology report
+                        pdf_path = generate_methodology_report_pdf(
+                            categories=categories_entered,
+                            model=model,
+                            column_name=description,
+                            num_rows=len(result_df),
+                            model_source=model_source,
+                            filename=original_filename,
+                            success_rate=success_rate,
+                            result_df=result_df,
+                            processing_time=processing_time,
+                            catllm_version=catllm_version,
+                            python_version=python_version,
+                            task_type="assign",
+                            input_type=input_type_selected,
+                            description=description
+                        )
+
+                        # Generate code
+                        code = generate_classify_code(input_type_selected, description, categories_entered, model, model_source, mode)
 
-                    if result_df is not None:
                         st.session_state.results = {
                             'df': result_df,
                             'csv_path': csv_path,
                             'pdf_path': pdf_path,
                             'code': code,
-                            'status': status,
+                            'status': f"Classified {len(result_df)} items in {processing_time:.1f}s",
                             'categories': categories_entered
                         }
-                        st.success(status)
+                        st.success(f"Classified {len(result_df)} items in {processing_time:.1f}s")
                         st.rerun()
                     else:
-                        st.error(status)
+                        st.error("No items were successfully classified")
 
 with col_output:
     st.markdown("### Results")