Update app_docker.py

app_docker.py

@@ -654,25 +654,43 @@ HTML_TEMPLATE = """
         });
 
         function updateDocumentsList() {
-            fetch('/documents').then(r => r.json()).then(d => {
+            fetch('/documents')
+            .then(r => {
+                if (!r.ok) throw new Error('Failed to fetch documents');
+                return r.json();
+            })
+            .then(d => {
                 const list = document.getElementById('documentsList');
-                if (d.documents.length === 0) {
+                if (!d.documents || Object.keys(d.documents).length === 0) {
                     list.innerHTML = '<p style="color: #999;">No documents uploaded yet</p>';
                 } else {
                     let html = '';
                     for (let doc in d.documents) {
-                        const info = d.documents[doc];
-                        const status = info.status || 'ready';
-                        const icon = status === 'processing' ? '⏳' : '✅';
-                        html += '<div class="document-status">';
-                        html += '<span class="status-icon">' + icon + '</span>';
-                        html += '<div style="flex: 1;">';
-                        html += '<div style="font-weight: 500; color: #2d3e50;">📄 ' + doc + '</div>';
-                        html += '<div style="font-size: 0.85rem; color: #999;">Status: ' + status + ' | Type: ' + info.type + '</div>';
-                        html += '</div></div>';
+                        if (d.documents.hasOwnProperty(doc)) {
+                            const info = d.documents[doc];
+                            const status = info.status || 'ready';
+                            const icon = status === 'processing' ? '⏳' : status === 'error' ? '❌' : '✅';
+                            const statusColor = status === 'error' ? '#dc3545' : status === 'processing' ? '#ffc107' : '#10b981';
+
+                            html += '<div class="document-status" style="border-left-color: ' + statusColor + ';">';
+                            html += '<span class="status-icon">' + icon + '</span>';
+                            html += '<div style="flex: 1;">';
+                            html += '<div style="font-weight: 500; color: #2d3e50;">📄 ' + doc + '</div>';
+
+                            let details = 'Status: ' + status + ' | Type: ' + (info.type || 'unknown');
+                            if (info.chunks) details += ' | Chunks: ' + info.chunks;
+                            if (info.error) details += ' | Error: ' + info.error.substring(0, 50);
+
+                            html += '<div style="font-size: 0.85rem; color: #999;">' + details + '</div>';
+                            html += '</div></div>';
+                        }
                     }
                     list.innerHTML = html;
                 }
+            })
+            .catch(error => {
+                const list = document.getElementById('documentsList');
+                list.innerHTML = '<p style="color: #dc3545;">❌ Error loading documents: ' + error.message + '</p>';
             });
         }
 
@@ -682,44 +700,68 @@ HTML_TEMPLATE = """
 
             const progressDiv = document.getElementById('uploadProgressDiv');
             progressDiv.style.display = 'block';
+            updateProgress(5);  // Start at 5%
 
             const formData = new FormData();
             for (let file of files) {
                 formData.append('files', file);
             }
 
-            // Better progress tracking
-            let progress = 0;
+            // Progress simulation during upload
+            let progress = 5;
             const progressInterval = setInterval(() => {
-                if (progress < 85) {
-                    progress += Math.random() * 25;
-                    updateProgress(Math.min(progress, 85));
+                if (progress < 80) {
+                    progress += Math.random() * 15;
+                    updateProgress(Math.min(progress, 80));
                 }
-            }, 300);
+            }, 400);
 
+            // Send upload request
             fetch('/upload', {
                 method: 'POST',
-                body: formData,
-                timeout: 300000  // 5 minute timeout
+                body: formData
             })
-            .then(r => {
+            .then(response => {
+                // Stop the progress simulation
                 clearInterval(progressInterval);
-                return r.json();
+                updateProgress(90);
+
+                // Check if response is ok
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                return response.json();
             })
-            .then(d => {
+            .then(data => {
+                // Upload completed successfully
                 updateProgress(100);
+
                 setTimeout(() => {
                     progressDiv.style.display = 'none';
-                    showStatus(d.message, d.success ? 'success' : 'error');
+
+                    // Show status message
+                    const successMsg = data.message || 'Upload completed';
+                    showStatus(successMsg, data.success ? 'success' : 'warning');
+
+                    // Refresh document list
                     updateDocumentsList();
+
+                    // Clear file input
                     document.getElementById('fileInput').value = '';
+
+                    // Clear progress tracking
                     progress = 0;
-                }, 1000);
+                }, 800);
             })
-            .catch(e => {
+            .catch(error => {
+                // Upload failed
                 clearInterval(progressInterval);
                 progressDiv.style.display = 'none';
-                showStatus('❌ Upload failed: ' + e.message, 'error');
+
+                let errorMsg = error.message || 'Upload failed';
+                showStatus('❌ ' + errorMsg, 'error');
+
+                // Clear file input
                 document.getElementById('fileInput').value = '';
                 progress = 0;
             });
@@ -770,34 +812,55 @@ def get_documents():
 
 @app.route('/upload', methods=['POST'])
 def upload_files():
+    """Handle document upload with proper error handling and status tracking"""
     files = request.files.getlist('files')
+
     if not files or len(files) == 0:
-        return jsonify({'success': False, 'message': '❌ No files uploaded'})
+        return jsonify({
+            'success': False,
+            'message': '❌ No files uploaded',
+            'successful': 0,
+            'failed': 0
+        })
+
+    successful = 0
+    failed = 0
+    errors = []
 
     try:
-        successful = 0
-        failed = 0
-        errors = []
+        import tempfile
+        import os as os_module
+        import logging
 
         for file in files:
             if not file or not file.filename:
                 continue
 
             filename = file.filename
+            temp_path = None
+
             try:
+                # Read file content
                 file_content = file.read()
+
                 if not file_content:
-                    documents[filename] = {'status': 'error', 'error': 'Empty file'}
+                    documents[filename] = {'status': 'error', 'error': 'Empty file', 'type': 'unknown'}
+                    errors.append(f"{filename}: Empty file")
                     failed += 1
                     continue
 
-                doc_type = 'pdf' if filename.endswith('.pdf') else 'csv' if filename.endswith('.csv') else None
-                if not doc_type:
-                    documents[filename] = {'status': 'error', 'error': 'Invalid file type'}
+                # Determine file type
+                if filename.lower().endswith('.pdf'):
+                    doc_type = 'pdf'
+                elif filename.lower().endswith('.csv'):
+                    doc_type = 'csv'
+                else:
+                    documents[filename] = {'status': 'error', 'error': 'Invalid file type', 'type': 'unknown'}
+                    errors.append(f"{filename}: Not PDF or CSV")
                     failed += 1
                     continue
 
-                # Update status: processing
+                # Mark as processing
                 documents[filename] = {
                     'type': doc_type,
                     'size': len(file_content),
@@ -805,108 +868,151 @@ def upload_files():
                     'uploaded_at': str(__import__('datetime').datetime.now())
                 }
 
-                # Process file in temp location
-                import tempfile
-                import os as os_module
-
+                # Write to temporary file
                 with tempfile.NamedTemporaryFile(delete=False, suffix=f".{doc_type}") as f:
                     temp_path = f.name
                     f.write(file_content)
+                    f.flush()
 
+                # Extract text from file
                 try:
-                    # Extract text
                     if doc_type == 'pdf':
                         text = PDFProcessor.extract_text(temp_path)
                     else:
                         text = CSVProcessor.extract_text(temp_path)
+                except Exception as extract_error:
+                    raise Exception(f"Text extraction failed: {str(extract_error)[:100]}")
 
-                    if not text or len(text.strip()) == 0:
-                        raise Exception('No text extracted from file')
+                if not text or len(text.strip()) == 0:
+                    raise Exception("No text could be extracted from file")
 
-                    # Chunk and embed
+                # Create chunks
+                try:
                     chunker = ChunkerService(512, 50)
                     chunks = chunker.chunk_text(text, {"doc_id": filename})
 
-                    if not chunks:
-                        raise Exception('No chunks created from text')
+                    if not chunks or len(chunks) == 0:
+                        raise Exception("No chunks created from text")
+                except Exception as chunk_error:
+                    raise Exception(f"Chunking failed: {str(chunk_error)[:100]}")
 
+                # Embed chunks
+                try:
                     embedded_chunks = services['embedding_service'].embed_chunks(chunks)
-                    services['vector_db_service'].add_chunks(embedded_chunks)
+                    if not embedded_chunks:
+                        raise Exception("Embedding failed")
 
-                    # Update status: ready
-                    documents[filename]['status'] = 'ready'
-                    documents[filename]['chunks'] = len(chunks)
-                    successful += 1
+                    services['vector_db_service'].add_chunks(embedded_chunks)
+                except Exception as embed_error:
+                    raise Exception(f"Embedding failed: {str(embed_error)[:100]}")
 
-                finally:
-                    # Clean up temp file
-                    try:
-                        os_module.unlink(temp_path)
-                    except:
-                        pass
+                # Mark as ready
+                documents[filename] = {
+                    'type': doc_type,
+                    'size': len(file_content),
+                    'status': 'ready',
+                    'chunks': len(chunks),
+                    'uploaded_at': str(__import__('datetime').datetime.now())
+                }
+                successful += 1
 
             except Exception as file_error:
                 error_msg = str(file_error)[:100]
                 documents[filename] = {
-                    'type': 'unknown',
+                    'type': doc_type if 'doc_type' in locals() else 'unknown',
                     'status': 'error',
                     'error': error_msg
                 }
                 errors.append(f"{filename}: {error_msg}")
                 failed += 1
+                __import__('logging').error(f"Upload error for {filename}: {str(file_error)}")
+
+            finally:
+                # Clean up temporary file
+                if temp_path:
+                    try:
+                        os_module.unlink(temp_path)
+                    except:
+                        pass
 
         # Build response message
-        message = f'✅ Processed {successful} file(s)'
-        if failed > 0:
-            message += f', ❌ Failed {failed} file(s)'
-            if errors and len(errors) <= 3:
-                message += f"\n{'; '.join(errors)}"
+        if successful == 0 and failed == 0:
+            message = '❌ No files processed'
+        elif successful > 0 and failed == 0:
+            message = f'✅ Successfully processed {successful} file(s)'
+        elif successful > 0 and failed > 0:
+            message = f'⚠️ Processed {successful} file(s), Failed {failed} file(s)'
+        else:
+            message = f'❌ Failed to process {failed} file(s)'
 
         return jsonify({
-            'success': failed == 0,
+            'success': failed == 0 and successful > 0,
             'message': message,
             'successful': successful,
-            'failed': failed
+            'failed': failed,
+            'errors': errors if errors else None
         })
+
     except Exception as e:
         error_msg = str(e)[:200]
-        return jsonify({'success': False, 'message': f'❌ Upload error: {error_msg}'})
+        __import__('logging').error(f"Upload endpoint error: {error_msg}")
+        return jsonify({
+            'success': False,
+            'message': f'❌ Upload error: {error_msg}',
+            'successful': 0,
+            'failed': len(files)
+        })
 
 @app.route('/query', methods=['POST'])
 def query():
     """RAG Query - with document retrieval"""
-    initialize_groq_from_env()
+    try:
+        initialize_groq_from_env()
+
+        if not services['retrieval_service']:
+            return jsonify({'success': False, 'error': '⚠️ GROQ_API_KEY not configured. Add it to HF Spaces Secrets.'})
 
-    if not services['retrieval_service']:
-        return jsonify({'success': False, 'error': 'GROQ_API_KEY not configured in Hugging Face Spaces secrets'})
+        data = request.json
+        query_text = data.get('query', '').strip()
+        if not query_text:
+            return jsonify({'success': False, 'error': 'Query is required'})
 
-    data = request.json
-    query_text = data.get('query', '')
-    if not query_text:
-        return jsonify({'success': False, 'error': 'Query is required'})
+        # Check if documents are uploaded
+        if not documents or len(documents) == 0:
+            return jsonify({'success': False, 'error': '❌ No documents uploaded. Please upload documents first.'})
+
+        try:
+            # Get embedding for query
+            query_embedding = services['embedding_service'].embed_text(query_text)
+
+            # Search for relevant documents
+            search_results = services['vector_db_service'].search(
+                query_embedding,
+                data.get('top_k', 5)
+            )
+
+            if not search_results or len(search_results) == 0:
+                return jsonify({'success': False, 'error': '❌ No relevant documents found. Try a different query.'})
+
+            # Generate answer using RAG pipeline
+            result = services['retrieval_service'].generate_with_pipeline(
+                query_text,
+                search_results,
+                data.get('model', 'llama-3.1-8b-instant'),
+                rag_mode=data.get('rag_mode', 'simple'),
+                temperature=float(data.get('temperature', 0.7)),
+                max_tokens=int(data.get('max_tokens', 1024))
+            )
+
+            return jsonify({'success': True, 'result': result})
+
+        except __import__('requests').exceptions.Timeout:
+            return jsonify({'success': False, 'error': 'Request timeout - Groq API is slow. Try again.'})
+        except Exception as query_error:
+            return jsonify({'success': False, 'error': f'Query error: {str(query_error)[:100]}'})
 
-    try:
-        query_embedding = services['embedding_service'].embed_text(query_text)
-        search_results = services['vector_db_service'].search(
-            query_embedding,
-            data.get('top_k', 5)
-        )
-
-        if not search_results:
-            return jsonify({'success': False, 'error': '❌ No relevant documents found. Please upload documents first.'})
-
-        result = services['retrieval_service'].generate_with_pipeline(
-            query_text,
-            search_results,
-            data.get('model', 'llama-3.1-8b-instant'),
-            rag_mode=data.get('rag_mode', 'simple'),
-            temperature=data.get('temperature', 0.7),
-            max_tokens=data.get('max_tokens', 1024)
-        )
-
-        return jsonify({'success': True, 'result': result})
     except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})
+        return jsonify({'success': False, 'error': f'Error: {str(e)[:100]}'})
 
 
 @app.route('/chat', methods=['POST'])