Upload 2580 files

app_docker.py

@@ -24,6 +24,8 @@ from app.core.constants import RAG_MODES, GROQ_MODELS, EMBEDDING_MODELS
 
 app = Flask(__name__)
 app.config['MAX_CONTENT_LENGTH'] = 50 * 1024 * 1024  # 50MB max upload
+app.config['UPLOAD_FOLDER'] = './data/uploads'
+app.config['SESSION_TIMEOUT'] = 600  # 10 minutes
 
 # Global state
 services = {
@@ -540,15 +542,19 @@ HTML_TEMPLATE = """
         // Direct Chat - No documents needed
         function submitChat() {
             const message = document.getElementById('chatInput').value;
-            if (!message) {
+            if (!message || message.trim() === '') {
                 showStatus('Please enter a message', 'warning');
                 return;
             }
-            showStatus('<div class="loading"></div> Chatting...', 'warning');
 
-            // Add user message to chat
+            const chatDiv = document.getElementById('chatMessages');
             addChatMessage(message, 'user');
             document.getElementById('chatInput').value = '';
+            showStatus('<div class="loading"></div> Waiting for response... (may take up to 30 seconds)', 'warning');
+
+            const timeout = 60000; // 60 second timeout
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
 
             fetch('/chat', {
                 method: 'POST',
@@ -556,20 +562,36 @@ HTML_TEMPLATE = """
                 body: JSON.stringify({
                     message: message,
                     model: document.getElementById('chatModel').value,
-                    temperature: parseFloat(document.getElementById('chatTemperature').value)
-                })
+                    temperature: parseFloat(document.getElementById('chatTemperature').value),
+                    max_tokens: 1024
+                }),
+                signal: controller.signal
+            })
+            .then(r => {
+                clearTimeout(timeoutId);
+                return r.json();
             })
-            .then(r => r.json())
             .then(data => {
                 if (data.success) {
                     addChatMessage(data.result.answer, 'assistant');
-                    showStatus('', '');
+                    showStatus('✅ Response received', 'success');
+                    setTimeout(() => showStatus('', ''), 3000);
                 } else {
-                    addChatMessage('❌ Error: ' + data.error, 'error');
+                    const errorMsg = data.error || 'Unknown error';
+                    addChatMessage('❌ ' + errorMsg, 'error');
+                    showStatus('❌ ' + errorMsg, 'error');
                 }
             })
             .catch(e => {
-                addChatMessage('❌ Error: ' + e, 'error');
+                clearTimeout(timeoutId);
+                let errorMsg = 'Request failed';
+                if (e.name === 'AbortError') {
+                    errorMsg = 'Request timeout - took too long';
+                } else {
+                    errorMsg = e.message || 'Network error';
+                }
+                addChatMessage('❌ ' + errorMsg, 'error');
+                showStatus('❌ ' + errorMsg, 'error');
             });
         }
 
@@ -662,33 +684,44 @@ HTML_TEMPLATE = """
             progressDiv.style.display = 'block';
 
             const formData = new FormData();
-            let totalFiles = files.length;
-            let processedFiles = 0;
-
             for (let file of files) {
                 formData.append('files', file);
             }
 
-            // Simulate progress
+            // Better progress tracking
             let progress = 0;
             const progressInterval = setInterval(() => {
-                if (progress < 90) {
-                    progress += Math.random() * 30;
-                    updateProgress(Math.min(progress, 90));
+                if (progress < 85) {
+                    progress += Math.random() * 25;
+                    updateProgress(Math.min(progress, 85));
                 }
-            }, 500);
+            }, 300);
 
-            fetch('/upload', {method: 'POST', body: formData})
-            .then(r => r.json())
-            .then(d => {
+            fetch('/upload', {
+                method: 'POST',
+                body: formData,
+                timeout: 300000  // 5 minute timeout
+            })
+            .then(r => {
                 clearInterval(progressInterval);
+                return r.json();
+            })
+            .then(d => {
                 updateProgress(100);
                 setTimeout(() => {
                     progressDiv.style.display = 'none';
                     showStatus(d.message, d.success ? 'success' : 'error');
                     updateDocumentsList();
                     document.getElementById('fileInput').value = '';
+                    progress = 0;
                 }, 1000);
+            })
+            .catch(e => {
+                clearInterval(progressInterval);
+                progressDiv.style.display = 'none';
+                showStatus('❌ Upload failed: ' + e.message, 'error');
+                document.getElementById('fileInput').value = '';
+                progress = 0;
             });
         });
 
@@ -738,61 +771,106 @@ def get_documents():
 @app.route('/upload', methods=['POST'])
 def upload_files():
     files = request.files.getlist('files')
-    if not files:
-        return jsonify({'success': False, 'message': 'No files uploaded'})
+    if not files or len(files) == 0:
+        return jsonify({'success': False, 'message': '❌ No files uploaded'})
 
     try:
         successful = 0
         failed = 0
+        errors = []
 
         for file in files:
-            if not file.filename:
+            if not file or not file.filename:
                 continue
 
-            file_content = file.read()
-            doc_type = 'pdf' if file.filename.endswith('.pdf') else 'csv'
-
+            filename = file.filename
             try:
+                file_content = file.read()
+                if not file_content:
+                    documents[filename] = {'status': 'error', 'error': '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'}
+                    failed += 1
+                    continue
+
                 # Update status: processing
-                documents[file.filename] = {
+                documents[filename] = {
                     'type': doc_type,
                     'size': len(file_content),
                     'status': 'processing',
                     'uploaded_at': str(__import__('datetime').datetime.now())
                 }
 
-                # Process file
+                # Process file in temp location
                 import tempfile
+                import os as os_module
+
                 with tempfile.NamedTemporaryFile(delete=False, suffix=f".{doc_type}") as f:
+                    temp_path = f.name
                     f.write(file_content)
+
+                try:
+                    # Extract text
                     if doc_type == 'pdf':
-                        text = PDFProcessor.extract_text(f.name)
+                        text = PDFProcessor.extract_text(temp_path)
                     else:
-                        text = CSVProcessor.extract_text(f.name)
+                        text = CSVProcessor.extract_text(temp_path)
 
-                # Chunk and embed
-                chunker = ChunkerService(512, 50)
-                chunks = chunker.chunk_text(text, {"doc_id": file.filename})
-                embedded_chunks = services['embedding_service'].embed_chunks(chunks)
-                services['vector_db_service'].add_chunks(embedded_chunks)
+                    if not text or len(text.strip()) == 0:
+                        raise Exception('No text extracted from file')
 
-                # Update status: ready
-                documents[file.filename]['status'] = 'ready'
-                documents[file.filename]['chunks'] = len(chunks)
-                successful += 1
+                    # Chunk and embed
+                    chunker = ChunkerService(512, 50)
+                    chunks = chunker.chunk_text(text, {"doc_id": filename})
+
+                    if not chunks:
+                        raise Exception('No chunks created from text')
+
+                    embedded_chunks = services['embedding_service'].embed_chunks(chunks)
+                    services['vector_db_service'].add_chunks(embedded_chunks)
+
+                    # Update status: ready
+                    documents[filename]['status'] = 'ready'
+                    documents[filename]['chunks'] = len(chunks)
+                    successful += 1
+
+                finally:
+                    # Clean up temp file
+                    try:
+                        os_module.unlink(temp_path)
+                    except:
+                        pass
 
             except Exception as file_error:
-                documents[file.filename]['status'] = 'error'
-                documents[file.filename]['error'] = str(file_error)
+                error_msg = str(file_error)[:100]
+                documents[filename] = {
+                    'type': 'unknown',
+                    'status': 'error',
+                    'error': error_msg
+                }
+                errors.append(f"{filename}: {error_msg}")
                 failed += 1
 
+        # Build response message
         message = f'✅ Processed {successful} file(s)'
         if failed > 0:
             message += f', ❌ Failed {failed} file(s)'
-
-        return jsonify({'success': failed == 0, 'message': message})
+            if errors and len(errors) <= 3:
+                message += f"\n{'; '.join(errors)}"
+
+        return jsonify({
+            'success': failed == 0,
+            'message': message,
+            'successful': successful,
+            'failed': failed
+        })
     except Exception as e:
-        return jsonify({'success': False, 'message': f'❌ Error: {str(e)}'})
+        error_msg = str(e)[:200]
+        return jsonify({'success': False, 'message': f'❌ Upload error: {error_msg}'})
 
 @app.route('/query', methods=['POST'])
 def query():
@@ -834,59 +912,66 @@ def query():
 @app.route('/chat', methods=['POST'])
 def chat():
     """Direct Chat - without 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 in Hugging Face Spaces secrets'})
+        if not services['retrieval_service']:
+            return jsonify({'success': False, 'error': 'GROQ_API_KEY not configured. Go to HF Secrets and add GROQ_API_KEY'})
 
-    data = request.json
-    message = data.get('message', '')
-    if not message:
-        return jsonify({'success': False, 'error': 'Message is required'})
+        data = request.json
+        message = data.get('message', '')
+        if not message:
+            return jsonify({'success': False, 'error': 'Message is required'})
 
-    try:
         model = data.get('model', 'llama-3.1-8b-instant')
-        temperature = data.get('temperature', 0.7)
-        max_tokens = data.get('max_tokens', 1024)
+        temperature = float(data.get('temperature', 0.7))
+        max_tokens = int(data.get('max_tokens', 1024))
 
         start_time = __import__('time').time()
 
         # Direct LLM call without document retrieval
-        groq_client = services['retrieval_service'].groq_client
-        response = groq_client.create_chat_completion(
-            model=model,
-            messages=[
-                {
-                    "role": "system",
-                    "content": "You are a helpful AI assistant. Provide clear, concise, and accurate answers."
-                },
-                {
-                    "role": "user",
-                    "content": message
-                }
-            ],
-            temperature=temperature,
-            max_tokens=max_tokens
-        )
-
-        answer = response['choices'][0]['message']['content']
-        response_time_ms = (__import__('time').time() - start_time) * 1000
-
-        tokens_used = {
-            'prompt': response['usage'].get('prompt_tokens', 0),
-            'completion': response['usage'].get('completion_tokens', 0),
-            'total': response['usage'].get('total_tokens', 0)
-        }
+        try:
+            groq_client = services['retrieval_service'].groq_client
+            response = groq_client.create_chat_completion(
+                model=model,
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You are a helpful AI assistant. Provide clear, concise, and accurate answers."
+                    },
+                    {
+                        "role": "user",
+                        "content": message
+                    }
+                ],
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+
+            answer = response['choices'][0]['message']['content']
+            response_time_ms = (__import__('time').time() - start_time) * 1000
+
+            tokens_used = {
+                'prompt': response['usage'].get('prompt_tokens', 0),
+                'completion': response['usage'].get('completion_tokens', 0),
+                'total': response['usage'].get('total_tokens', 0)
+            }
 
-        return jsonify({'success': True, 'result': {
-            'answer': answer,
-            'model': model,
-            'tokens_used': tokens_used,
-            'response_time_ms': response_time_ms,
-            'mode': 'direct_chat'
-        }})
+            return jsonify({'success': True, 'result': {
+                'answer': answer,
+                'model': model,
+                'tokens_used': tokens_used,
+                'response_time_ms': response_time_ms,
+                'mode': 'direct_chat'
+            }})
+        except __import__('requests').exceptions.Timeout:
+            return jsonify({'success': False, 'error': 'Request timeout - Groq API is taking too long. Try again.'})
+        except __import__('requests').exceptions.ConnectionError:
+            return jsonify({'success': False, 'error': 'Connection error - Unable to reach Groq API. Check internet.'})
     except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})
+        import traceback
+        __import__('logging').error(f"Chat error: {str(e)}\n{traceback.format_exc()}")
+        return jsonify({'success': False, 'error': f'Error: {str(e)[:100]}'})
 
 if __name__ == '__main__':
     os.makedirs('./data/uploads', exist_ok=True)