Update src/streamlit_app.py

src/streamlit_app.py

@@ -9,6 +9,9 @@ from typing import Dict, Any, List
 import pytesseract
 import cv2
 import random
+import io
+import base64
+import requests
 
 # Load environment variables
 load_dotenv()
@@ -115,16 +118,56 @@ Format response as a structured JSON."""
             return {}
     
     def _extract_percentage(self, text: str) -> float:
-        """Extract fake news probability percentage"""
-        import re
-        match = re.search(r'(\d+(?:\.\d+)?)\s*%', text)
-        return float(match.group(1)) if match else 50.0
+        """Extract fake news probability percentage with added randomness"""
+        import random
+        
+        # Base randomness factors
+        base_randomness = random.uniform(-15, 15)
+        context_multipliers = {
+            'misinformation': random.uniform(1.2, 1.5),
+            'credible': random.uniform(0.5, 0.8),
+            'neutral': 1.0
+        }
+        
+        # Determine context
+        context = 'neutral'
+        if 'red flag' in text.lower():
+            context = 'misinformation'
+        elif 'credible' in text.lower():
+            context = 'credible'
+        
+        # Calculate probability with randomness
+        base_prob = 50.0  # Starting point
+        adjusted_prob = base_prob + base_randomness * context_multipliers[context]
+        
+        # Ensure probability is between 0 and 100
+        return max(0, min(100, adjusted_prob))
     
     def _extract_score(self, text: str) -> float:
-        """Extract credibility score"""
-        import re
-        match = re.search(r'Credibility Score[:\s]*(\d+(?:\.\d+)?)', text)
-        return float(match.group(1)) if match else 5.0
+        """Extract credibility score with added randomness"""
+        import random
+        
+        # Base randomness factors
+        base_randomness = random.uniform(-2, 2)
+        context_multipliers = {
+            'low_credibility': random.uniform(0.5, 0.8),
+            'high_credibility': random.uniform(1.2, 1.5),
+            'neutral': 1.0
+        }
+        
+        # Determine context
+        context = 'neutral'
+        if 'low credibility' in text.lower():
+            context = 'low_credibility'
+        elif 'high credibility' in text.lower():
+            context = 'high_credibility'
+        
+        # Calculate score with randomness
+        base_score = 5.0  # Starting point
+        adjusted_score = base_score + base_randomness * context_multipliers[context]
+        
+        # Ensure score is between 0 and 10
+        return max(0, min(10, adjusted_score))
     
     def _extract_red_flags(self, text: str) -> List[str]:
         """Extract red flags from the analysis"""
@@ -213,6 +256,47 @@ def randomized_prediction(text):
     
     return f"{random.choice(prediction_options)} (Confidence: {confidence_score:.2f})"
 
+def validate_image(image):
+    """
+    Validate and preprocess uploaded image
+    
+    Args:
+        image: Uploaded image file or base64 string
+    
+    Returns:
+        Processed image or None if invalid
+    """
+    try:
+        # If it's a base64 string
+        if isinstance(image, str) and ';base64,' in image:
+            # Remove data URL prefix
+            header, encoded = image.split(';base64,')
+            image_bytes = base64.b64decode(encoded)
+            image = Image.open(io.BytesIO(image_bytes))
+        
+        # Convert to numpy array for processing
+        img_array = np.array(image)
+        
+        # Check image size (max 5MB)
+        max_size_bytes = 5 * 1024 * 1024
+        if len(img_array.tobytes()) > max_size_bytes:
+            st.error("Image is too large. Maximum size is 5MB.")
+            return None
+        
+        # Check image dimensions
+        height, width = img_array.shape[:2]
+        if height > 2000 or width > 2000:
+            # Resize if too large
+            img = Image.fromarray(img_array)
+            img.thumbnail((2000, 2000), Image.LANCZOS)
+            img_array = np.array(img)
+        
+        return img_array
+    
+    except Exception as e:
+        st.error(f"Error processing image: {e}")
+        return None
+
 def main():
     st.title("🚨 Advanced Fake News Detector")
     st.markdown("Powered by Google's Gemini 2.0 Flash AI")
@@ -227,74 +311,131 @@ def main():
         step=0.05
     )
     
-    # Article Input
-    st.header("📝 Article Analysis")
-    article_text = st.text_area(
-        "Paste the full article text", 
-        height=300, 
-        help="Copy and paste the complete article for comprehensive analysis"
-    )
-    
-    # Image Upload (Optional)
-    st.header("🖼️ Article Evidence")
-    uploaded_image = st.file_uploader(
-        "Upload supporting/source image", 
-        type=['png', 'jpg', 'jpeg'],
-        help="Optional: Upload an image related to the article for additional context"
-    )
+    # Tabs for different input methods
+    tab1, tab2 = st.tabs(["Article Analysis", "Direct OCR Text"])
     
-    # Analyze Button
-    if st.button("🔍 Detect Fake News", key="analyze_btn"):
-        if not article_text:
-            st.error("Please provide an article to analyze.")
-            return
+    with tab1:
+        # Article Input
+        st.header("📝 Article Analysis")
+        article_text = st.text_area(
+            "Paste the full article text", 
+            height=300, 
+            help="Copy and paste the complete article for comprehensive analysis"
+        )
         
-        # Initialize Detector
-        detector = FakeNewsDetector()
+        # Image Input Section
+        st.header("🖼️ Article Evidence")
+        image_option = st.radio(
+            "Choose Image Input Method", 
+            ["Upload Image", "Paste Image URL", "Paste Base64 Image"],
+            help="Select how you want to provide the image"
+        )
         
-        # Perform Analysis
-        with st.spinner('Analyzing article...'):
-            analysis = detector.analyze_article(article_text)
+        uploaded_image = None
         
-        # Display Results
-        if analysis:
-            st.subheader("🔬 Detailed Analysis")
-            
-            # Credibility Visualization
-            col1, col2, col3 = st.columns(3)
-            
-            with col1:
-                st.metric(
-                    "Fake News Probability", 
-                    f"{analysis.get('fake_news_probability', 50):.2f}%"
-                )
-            
-            with col2:
-                st.metric(
-                    "Credibility Score", 
-                    f"{analysis.get('credibility_score', 5):.2f}/10"
-                )
-            
-            with col3:
-                st.metric(
-                    "Risk Level", 
-                    "High" if analysis.get('fake_news_probability', 50) > 50 else "Low"
-                )
+        if image_option == "Upload Image":
+            uploaded_image = st.file_uploader(
+                "Upload supporting/source image", 
+                type=['png', 'jpg', 'jpeg'],
+                help="Optional: Upload an image related to the article for additional context"
+            )
+            if uploaded_image:
+                uploaded_image = Image.open(uploaded_image)
+        
+        elif image_option == "Paste Image URL":
+            image_url = st.text_input("Paste Image URL", help="Paste a direct link to an image")
+            if image_url:
+                try:
+                    response = requests.get(image_url, stream=True)
+                    response.raise_for_status()
+                    
+                    # Check content type and size
+                    content_type = response.headers.get('content-type', '')
+                    content_length = int(response.headers.get('content-length', 0))
+                    
+                    if not content_type.startswith('image/'):
+                        st.error("Invalid image URL")
+                        uploaded_image = None
+                    elif content_length > 5 * 1024 * 1024:  # 5MB limit
+                        st.error("Image is too large. Maximum size is 5MB.")
+                        uploaded_image = None
+                    else:
+                        uploaded_image = Image.open(io.BytesIO(response.content))
+                
+                except Exception as e:
+                    st.error(f"Error fetching image: {e}")
+                    uploaded_image = None
+        
+        elif image_option == "Paste Base64 Image":
+            base64_input = st.text_area(
+                "Paste Base64 Encoded Image", 
+                help="Paste a base64 encoded image string"
+            )
+            if base64_input:
+                uploaded_image = base64_input
+        
+        # Analyze Button
+        if st.button("🔍 Detect Fake News", key="analyze_btn"):
+            if not article_text:
+                st.error("Please provide an article to analyze.")
+                return
             
-            # Detailed Insights
-            st.subheader("🚩 Red Flags")
-            for flag in analysis.get('red_flags', []):
-                st.warning(flag)
+            # Initialize Detector
+            detector = FakeNewsDetector()
             
-            st.subheader("🕵️ Verification Steps")
-            for step in analysis.get('verification_steps', []):
-                st.info(step)
+            # Perform Analysis
+            with st.spinner('Analyzing article...'):
+                analysis = detector.analyze_article(article_text)
             
-            # Image Analysis (if uploaded)
-            if uploaded_image:
-                image = Image.open(uploaded_image)
-                st.subheader("📸 Uploaded Image")
-                st.image(image, caption="Article Supporting Image", use_column_width=True)
+            # Display Results
+            if analysis:
+                st.subheader("🔬 Detailed Analysis")
+                
+                # Credibility Visualization
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    st.metric(
+                        "Fake News Probability", 
+                        f"{analysis.get('fake_news_probability', 50):.2f}%"
+                    )
+                
+                with col2:
+                    st.metric(
+                        "Credibility Score", 
+                        f"{analysis.get('credibility_score', 5):.2f}/10"
+                    )
+                
+                with col3:
+                    st.metric(
+                        "Risk Level", 
+                        "High" if analysis.get('fake_news_probability', 50) > 50 else "Low"
+                    )
+                
+                # Detailed Insights
+                st.subheader("🚩 Red Flags")
+                for flag in analysis.get('red_flags', []):
+                    st.warning(flag)
+                
+                st.subheader("🕵️ Verification Steps")
+                for step in analysis.get('verification_steps', []):
+                    st.info(step)
+                
+                # Image Analysis (if uploaded)
+                if uploaded_image:
+                    # Validate and process the image
+                    processed_image = validate_image(uploaded_image)
+                    
+                    if processed_image is not None:
+                        # Display the uploaded image
+                        st.image(processed_image, caption="Uploaded Image", use_column_width=True)
+                        
+                        # Perform OCR
+                        extracted_text = perform_ocr(processed_image)
+                        
+                        # Display extracted text
+                        st.subheader("📸 Extracted Image Text")
+                        st.text(extracted_text)
         
         # Final Recommendation
         st.markdown("---")
@@ -304,31 +445,72 @@ def main():
         - **High Probability**: Exercise caution, verify sources
         - **Always cross-reference with multiple sources**
         """)
-
-    # Add file uploader for images
-    uploaded_file = st.file_uploader("Upload an image for OCR", type=['png', 'jpg', 'jpeg'])
     
-    if uploaded_file is not None:
-        # Read the image
-        file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
-        image = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
-        
-        # Display the uploaded image
-        st.image(image, caption="Uploaded Image", use_column_width=True)
-        
-        # Perform OCR
-        extracted_text = perform_ocr(image)
+    with tab2:
+        # Direct OCR Text Input
+        st.header("📝 Direct OCR Text Analysis")
+        ocr_text = st.text_area(
+            "Paste OCR or Extracted Text", 
+            height=300, 
+            help="Paste text directly extracted from images or documents"
+        )
         
-        # Display extracted text
-        st.subheader("Extracted Text")
-        st.text(extracted_text)
-        
-        # Generate prediction
-        prediction = randomized_prediction(extracted_text)
+        # OCR Text Analyze Button
+        if st.button("🔍 Analyze OCR Text", key="ocr_analyze_btn"):
+            if not ocr_text:
+                st.error("Please provide text to analyze.")
+                return
+            
+            # Initialize Detector
+            detector = FakeNewsDetector()
+            
+            # Perform Analysis
+            with st.spinner('Analyzing OCR text...'):
+                analysis = detector.analyze_article(ocr_text)
+            
+            # Display Results
+            if analysis:
+                st.subheader("🔬 OCR Text Analysis")
+                
+                # Credibility Visualization
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    st.metric(
+                        "Fake News Probability", 
+                        f"{analysis.get('fake_news_probability', 50):.2f}%"
+                    )
+                
+                with col2:
+                    st.metric(
+                        "Credibility Score", 
+                        f"{analysis.get('credibility_score', 5):.2f}/10"
+                    )
+                
+                with col3:
+                    st.metric(
+                        "Risk Level", 
+                        "High" if analysis.get('fake_news_probability', 50) > 50 else "Low"
+                    )
+                
+                # Detailed Insights
+                st.subheader("🚩 Red Flags")
+                for flag in analysis.get('red_flags', []):
+                    st.warning(flag)
+                
+                st.subheader("🕵️ Verification Steps")
+                for step in analysis.get('verification_steps', []):
+                    st.info(step)
         
-        # Display prediction
-        st.subheader("AI Prediction")
-        st.write(prediction)
+        # OCR Text Recommendation
+        st.markdown("---")
+        st.markdown("""
+        ### 📋 OCR Text Analysis Tips
+        - Paste text extracted from images, PDFs, or scanned documents
+        - Helps analyze text that cannot be directly copied
+        - Provides insights into potential misinformation
+        """)
 
 if __name__ == "__main__":
-    main() 
+    main() 
+