Update app.py

app.py

@@ -307,8 +307,8 @@ def create_summary_image(annotated_img, labels, objects, text):
         font = ImageFont.load_default()
         title_font = ImageFont.load_default()
     
-    # Draw title
-    draw.text((20, img_height + 20), "Cosmick Cloud AI Analyzer Results", fill=(65, 105, 225), font=title_font)
+    # Draw title - using dark blue color
+    draw.text((20, img_height + 20), "Cosmick Cloud AI Analyzer Results", fill=(0, 0, 139), font=title_font)
     
     # Draw divider line
     draw.line([(0, img_height + 50), (img_width, img_height + 50)], fill=(200, 200, 200), width=2)
@@ -344,18 +344,19 @@ def create_summary_image(annotated_img, labels, objects, text):
                 draw.text((mid_point + 20, y_pos), f"{obj}: {confidence}%", fill=(0, 0, 128), font=font)
                 y_pos += 25
     
-    # Add text detection summary at the bottom
+    # Add text detection summary at the bottom with improved visibility
     if text:
         bottom_y = img_height + result_height - 80
         draw.text((20, bottom_y), "📝 Text Detected:", fill=(0, 0, 0), font=title_font)
         # Truncate text if too long
         display_text = text if len(text) < 100 else text[:97] + "..."
-        draw.text((20, bottom_y + 30), display_text, fill=(128, 0, 0), font=font)
+        # Change text color to dark red for better visibility
+        draw.text((20, bottom_y + 30), display_text, fill=(139, 0, 0), font=font)
     
-    # Add timestamp
+    # Add timestamp with darker color
     timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
     draw.text((img_width - 200, img_height + result_height - 30), 
-              f"Generated: {timestamp}", fill=(100, 100, 100), font=font)
+              f"Generated: {timestamp}", fill=(50, 50, 50), font=font)
     
     return summary_img
 
@@ -533,6 +534,18 @@ def analyze_document(file_content, processor_id, location="us"):
                 
             tables.append({"headers": headers, "data": table_data})
     
+    # Store results in session state for chatbot context
+    results = (text, entities, tables)
+    st.session_state.analysis_results = {
+        "text": text,
+        "entities": entities,
+        "tables": tables,
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    # Update vectorstore with new results
+    update_vectorstore_with_results(results)
+    
     return text, entities, tables
 
 def create_bigquery_table(dataset_id, table_id, schema=None):
@@ -609,11 +622,24 @@ def upload_csv_to_bigquery(file, dataset_id, table_id, append=False):
     # Get the table
     table = bq_client.get_table(table_ref)
     
-    return {
+    result = {
         "num_rows": table.num_rows,
         "size_bytes": table.num_bytes,
         "schema": [field.name for field in table.schema]
     }
+    
+    # Store results in session state for chatbot context
+    st.session_state.analysis_results = {
+        "data_source": f"{dataset_id}.{table_id}",
+        "num_rows": table.num_rows,
+        "schema": [field.name for field in table.schema],
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    # Update vectorstore with new results
+    update_vectorstore_with_results(result)
+    
+    return result
 
 def run_bigquery(query):
     """Run a BigQuery query and return results"""
@@ -629,6 +655,16 @@ def run_bigquery(query):
     # Convert to dataframe
     df = results.to_dataframe()
     
+    # Store results in session state for chatbot context
+    st.session_state.analysis_results = {
+        "query": query,
+        "results": df,
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    # Update vectorstore with new results
+    update_vectorstore_with_results(df)
+    
     return df
 
 def list_bigquery_resources():
@@ -686,8 +722,19 @@ def process_video_file(video_file, analysis_types):
     output_fps = fps * 0.6
     st.info(f"Output video will be slowed down to {output_fps:.1f} FPS (60% of original speed) for better visualization.")
     
-    # Create video writer with higher quality settings
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # MP4 codec
+    # Create video writer with H.264 codec for better compatibility
+    # Try different codec options based on platform compatibility
+    try:
+        # First try H.264 codec (most widely compatible)
+        if cv2.__version__.startswith('4'):
+            fourcc = cv2.VideoWriter_fourcc(*'avc1')  # H.264 codec
+        else:
+            # Fallback to older codec naming
+            fourcc = cv2.VideoWriter_fourcc(*'H264')
+    except Exception:
+        # If H.264 isn't available, fall back to MP4V
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    
     out = cv2.VideoWriter(output_path, fourcc, output_fps, (width, height), isColor=True)
     
     # Process every Nth frame to reduce API calls but increase from 10 to 5 for more detail
@@ -887,7 +934,16 @@ def process_video_file(video_file, analysis_types):
         os.unlink(output_path)
         
         # Return both the video and the detection statistics
-        return processed_video_bytes, {"detection_stats": detection_stats}
+        processed_video_bytes = processed_video_bytes
+        results = {"detection_stats": detection_stats}
+        
+        # Store results in session state for chatbot context
+        st.session_state.analysis_results = results
+        
+        # Update vectorstore with new results
+        update_vectorstore_with_results(results)
+        
+        return processed_video_bytes, results
         
     except Exception as e:
         # Clean up on error
@@ -1026,36 +1082,86 @@ def update_vectorstore_with_results(results):
         return
     
     try:
-        # Convert results to document format
-        results_text = f"""
-        Analysis Results at {results.get('timestamp', time.strftime('%Y-%m-%d %H:%M:%S'))}:
-        
-        Labels detected: {', '.join(results.get('labels', {}).keys())}
-        
-        Objects detected: {', '.join(results.get('objects', {}).keys())}
-        
-        Text detected: {results.get('text', 'None')}
-        """
+        # Convert results to document format based on type
+        results_text = ""
+        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+        
+        # Check what type of results we have
+        if isinstance(results, dict):
+            if "labels" in results:  # Image analysis results
+                results_text = f"""
+                Image Analysis Results at {results.get('timestamp', timestamp)}:
+                
+                Labels detected: {', '.join(results.get('labels', {}).keys())}
+                
+                Objects detected: {', '.join(results.get('objects', {}).keys())}
+                
+                Text detected: {results.get('text', 'None')}
+                """
+            elif "detection_stats" in results:  # Video analysis results
+                detection_stats = results.get("detection_stats", {})
+                results_text = f"""
+                Video Analysis Results at {timestamp}:
+                
+                Objects detected: {', '.join(detection_stats.get('objects', {}).keys())}
+                
+                Faces detected: {detection_stats.get('faces', 0)}
+                
+                Text blocks detected: {detection_stats.get('text_blocks', 0)}
+                
+                Labels detected: {', '.join(detection_stats.get('labels', {}).keys())}
+                """
+            elif "data" in results:  # Data analysis results
+                results_text = f"""
+                Data Analysis Results at {timestamp}:
+                
+                Dataset loaded with {results.get('num_rows', 0)} rows
+                
+                Columns: {', '.join(results.get('schema', []))}
+                """
+        elif isinstance(results, tuple) and len(results) == 3:  # Document analysis results
+            text, entities, tables = results
+            entities_text = ", ".join(f"{k}: {v}" for k, v in entities.items())
+            tables_info = f"{len(tables)} tables extracted" if tables else "No tables extracted"
+            
+            results_text = f"""
+            Document Analysis Results at {timestamp}:
+            
+            Extracted text length: {len(text)} characters
+            
+            Entities detected: {entities_text}
+            
+            Tables: {tables_info}
+            """
+        elif isinstance(results, pd.DataFrame):  # Query results
+            results_text = f"""
+            Query Results at {timestamp}:
+            
+            Retrieved {len(results)} rows of data
+            
+            Columns: {', '.join(results.columns)}
+            """
         
         # Create a document
-        text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=1000,
-            chunk_overlap=200
-        )
-        docs = text_splitter.create_documents([results_text])
-        
-        # Initialize vectorstore if it doesn't exist in session state
-        if "vectorstore" not in st.session_state:
-            docs_data = process_documents()
-            st.session_state.vectorstore = create_vectorstore(docs_data)
-        
-        # Add the new documents to the vectorstore
-        if st.session_state.vectorstore and docs:
-            api_key = os.environ.get("OPENAI_API_KEY")
-            if api_key:
-                embeddings = OpenAIEmbeddings(openai_api_key=api_key)
-                st.session_state.vectorstore.add_documents(docs)
-                st.session_state.vectorstore.save_local("vectorstore")
+        if results_text:
+            text_splitter = RecursiveCharacterTextSplitter(
+                chunk_size=1000,
+                chunk_overlap=200
+            )
+            docs = text_splitter.create_documents([results_text])
+            
+            # Initialize vectorstore if it doesn't exist in session state
+            if "vectorstore" not in st.session_state:
+                docs_data = process_documents()
+                st.session_state.vectorstore = create_vectorstore(docs_data)
+            
+            # Add the new documents to the vectorstore
+            if st.session_state.vectorstore and docs:
+                api_key = os.environ.get("OPENAI_API_KEY")
+                if api_key:
+                    embeddings = OpenAIEmbeddings(openai_api_key=api_key)
+                    st.session_state.vectorstore.add_documents(docs)
+                    st.session_state.vectorstore.save_local("vectorstore")
     except Exception as e:
         st.warning(f"Error updating vectorstore: {str(e)}")
 
@@ -1585,8 +1691,14 @@ def main():
                                     mime="video/mp4"
                                 )
                                 
-                                # Display processed video
-                                st.video(processed_video)
+                                # Display processed video with fallback options
+                                st.markdown("### Processed Video")
+                                st.markdown("If the video below doesn't play correctly, please use the download button above to view it locally.")
+                                try:
+                                    st.video(processed_video)
+                                except Exception as e:
+                                    st.error(f"Error displaying video in browser: {str(e)}")
+                                    st.info("Please download the video using the button above and play it in your local media player.")
                                 
                                 # Show detailed analysis results
                                 st.markdown("### Detailed Analysis Results")