Initial commit

.env.example

@@ -0,0 +1,35 @@
+# Example .env file for Fake News Detection System
+# Rename this file to .env and modify values as needed
+
+# GDELT API configuration
+# No API key needed for GDELT
+MAX_ARTICLES_PER_QUERY=250
+
+# Ranking configuration
+TOP_K_ARTICLES=250
+SIMILARITY_MODEL=intfloat/multilingual-e5-base
+MIN_SIMILARITY_THRESHOLD=0.1
+
+# Display configuration
+SHOW_SIMILARITY_SCORES=true
+SHOW_PUBLISH_DATE=true
+SHOW_URL=true
+
+# Domain filtering configuration
+USE_WHITELIST_ONLY=false
+
+# Google Gemini API
+# Get your API key from https://ai.google.dev/
+GEMINI_API_KEY=your_gemini_api_key_here
+GEMINI_MODEL=gemini-2.5-flash
+
+# Google Search API (SerpAPI)
+# Get your API key from https://serpapi.com/
+SERPAPI_KEY=your_serpapi_key_here
+
+# Bias Analysis configuration
+TOP_ARTICLES_PER_BIAS_CATEGORY=5
+
+# Server configuration
+PORT=5000
+DEBUG=false

.gitattributes

@@ -0,0 +1,2 @@
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,40 @@
+# Environment variables
+.env
+.env.*
+!.env.example
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE files
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store

README.md

@@ -0,0 +1,73 @@
+# Fake News Detection (GDELT + Gemini) with Minimal UI
+
+This app takes a user query, builds robust GDELT queries via Gemini, fetches articles, analyzes outlet bias, ranks articles with local embeddings, and returns a concise, multi‑perspective summary. The UI renders exactly what the backend returns (no extra formatting or hardcoded values).
+
+## Key Features
+- Query expansion: 10 GDELT query variations, language-preserving, AND-only operators.
+- Sensitive-query guard: pornography/religion and similar sensitive topics short‑circuit with “I cannot respond to this query.”
+- GDELT ingestion and normalization.
+- Gemini-driven bias analysis with categories; one category is strictly named “unbiased”.
+- Per-category ranking using a cached local embedding model (SentenceTransformers), shared across requests.
+- Multi‑perspective summarization:
+  - Sends top URLs from all categories (including unbiased) to Gemini.
+  - Summary lists sources grouped by category with up to 5 URLs per category.
+  - Appends the “reasoning” string (from bias analysis) after the sources.
+- Optional domain whitelisting (toggle in .env).
+- Terminal and UI show the exact same summary string.
+
+## Requirements
+- Python 3.11+
+- Conda/venv recommended
+- Packages: flask, flask-cors, python-dotenv, requests, sentence-transformers, torch, google-generativeai
+
+## Setup
+1. Create and activate environment (example with conda):
+   - conda create -n fake_news_detection python=3.11 -y
+   - conda activate fake_news_detection
+2. Install deps:
+   - pip install -r requirements.txt  (if present) or install the packages listed above.
+3. Copy .env.example to .env and set values:
+   - GEMINI_API_KEY, GEMINI_MODEL (e.g., gemini-1.5-pro or gemini-2.5-pro)
+   - MAX_ARTICLES_PER_QUERY, TOP_N_PER_CATEGORY, MIN_SIMILARITY_THRESHOLD
+   - SIMILARITY_MODEL (e.g., intfloat/multilingual-e5-base)
+   - SHOW_SIMILARITY_SCORES, SHOW_PUBLISH_DATE, SHOW_URL
+   - USE_WHITELIST_ONLY (true/false)
+   - PORT, DEBUG
+
+## Run
+- Linux:
+  - chmod +x ./main.py
+  - ./main.py
+- Visit http://127.0.0.1:5000
+
+## API
+POST /api/detect
+- Body: {"query": "your question"}
+- Returns (simplified):
+```
+{
+  "query": "...",
+  "summary": "MULTI-PERSPECTIVE FACTUAL SUMMARY...\n\n...SOURCES BY CATEGORY...\n\n...REASONING: ...",
+  "status": "ok" | "no_results" | "blocked"
+}
+```
+Notes:
+- If the query is sensitive, status=blocked and summary contains: “I cannot respond to this query.”
+- Only the summary string is printed to terminal and sent to UI, and the UI renders it verbatim.
+
+## Behavior Details
+- Local embedding model is loaded once and cached for reuse across requests.
+- Gemini runs in the cloud (no caching).
+- Bias categories come from Gemini; one is enforced/normalized to exactly “unbiased”.
+- Summarization uses top URLs from all categories and instructs Gemini to:
+  - Group sources by category,
+  - List up to 5 URLs per category (numbering restarts at 1 inside each category),
+  - Then append the bias-analysis “reasoning” section.
+
+## Whitelist Filtering
+- USE_WHITELIST_ONLY=true limits articles to whitelisted domains.
+- When false, all domains are considered.
+
+## Frontend
+- static/ contains a minimal JS client.
+- It outputs exactly the summary string received from backend (no hardcoded counts/colors/extra text; no horizontal scrolling).

README_GEMINI.md

@@ -0,0 +1,46 @@
+# Gemini Integration: GDELT Query Builder & Summarization
+
+This project uses Google’s Gemini for:
+- Building 10 language-preserving GDELT query variations.
+- Analyzing outlet bias and returning categories (must include exactly “unbiased”).
+- Producing a multi‑perspective factual summary grouped by bias categories.
+
+Gemini runs in the cloud and is not cached. The local embedding model is cached and shared across requests.
+
+## Setup
+- Get an API key from https://ai.google.dev/
+- .env:
+  - GEMINI_API_KEY=your_key
+  - GEMINI_MODEL=gemini-1.5-pro (or gemini-2.5-pro / flash variants)
+
+## Query Builder (gdelt_query_builder.py)
+- Generates EXACTLY 10 variations separated by |||.
+- Preserves user language.
+- Uses AND-only operators between terms.
+- Adds sourcecountry/sourceregion and datetimes when implied.
+- Sensitive-query guard:
+  - The system prompt instructs Gemini to return the literal token INAPPROPRIATE_QUERY_DETECTED for sensitive topics (e.g., pornography, explicit adult content, certain religious questions flagged by policy).
+  - The backend detects this and immediately returns a summary “I cannot respond to this query.” (status=blocked).
+
+Example request body to backend:
+```
+{"query": "news about war in Ukraine"}
+```
+
+## Bias Analysis
+- Gemini returns bias categories and counts; one category is normalized to exactly “unbiased”.
+- Reasoning text explains the categorization logic; this is appended after sources in the final summary.
+
+## Summarization
+- Backend sends top URLs from all categories (including unbiased) to Gemini, labeled by category.
+- Gemini instruction highlights:
+  - Produce a concise factual answer first.
+  - Then list SOURCES BY CATEGORY with up to 5 URLs per category.
+  - Numbering restarts at 1 per category (1–5 for each).
+  - After sources, append “REASONING:” with the bias-analysis reasoning string.
+- The backend returns only the final formatted summary string; UI renders it verbatim.
+
+## Notes
+- No Gemini model caching (cloud API).
+- Local embedding model (SentenceTransformers) is cached once and reused.
+- Optional whitelist filtering toggled via USE_WHITELIST_ONLY in .env.

bias_analyzer.py

@@ -0,0 +1,470 @@
+"""
+bias_analyzer.py - Module for bias analysis, categorization, and summarization
+
+This module provides functions for:
+1. Analyzing bias in news sources
+2. Categorizing articles by bias category
+3. Creating embeddings for each category
+4. Summarizing information from unbiased sources
+"""
+
+import os
+import re
+import json
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+# Import from ranker to use the shared model cache and device detection
+from ranker import DEVICE, _MODEL_CACHE
+
+# Load environment variables
+load_dotenv()
+
+# Set up the Gemini API with the API key from environment variables
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
+if not GEMINI_API_KEY:
+    raise ValueError("GEMINI_API_KEY environment variable not set. Please add it to your .env file.")
+
+# Initialize the Gemini client
+genai.configure(api_key=GEMINI_API_KEY)
+
+
+def analyze_bias(query, outlet_names, model_name):
+    """
+    Analyzes bias in news sources and categorizes them.
+    
+    Args:
+        query (str): The original user query
+        outlet_names (list): List of unique outlet names to categorize
+        model_name (str): The name of the Gemini model to use
+        
+    Returns:
+        dict: Dictionary containing bias analysis results and categorized articles
+    """
+    # Only print status messages if debug mode is enabled
+    print(f"Analyzing potential bias in {len(outlet_names)} unique news outlets...")
+    
+    try:
+        # Define system prompt for bias analysis
+        bias_analysis_prompt = """
+        You are an expert media bias analyzer. Your task is to categorize news sources into bias categories based on their reporting styles, focus, and potential biases.
+        
+        Analyze the provided list of news outlets in the context of the user's query. Identify any number of distinct bias categories that best describe the potential biases in these sources, plus EXACTLY one "unbiased" category (not "neutral" or any other name). The categories should reflect the relevant dimensions of bias for this specific query and set of outlets.
+        
+        For example, depending on the query and outlets, your categories might be:
+        - Query about climate change: "industry-funded", "environmental-activist", "unbiased"
+        - Query about international conflict: "pro-western", "state-controlled", "anti-western", "regional-perspective", "unbiased"
+        - Query about economic policy: "pro-business", "labor-oriented", "progressive", "conservative", "unbiased"
+        
+        Consider these factors:
+        - Historical reporting patterns and perspectives
+        - Ownership and financial interests
+        - Terminology and framing used in headlines
+        - Fact-based vs. opinion-heavy reporting
+        - Regional or national interests that may influence coverage
+        
+        CRITICAL REQUIREMENT: One category MUST be exactly named "unbiased" (not "neutral", "balanced", "centrist", or any other variation).
+        
+        Return your response in the exact JSON format shown below:
+        {
+          "categories": {
+            "bias category 1": [list of outlet names in this category],
+            "bias category 2": [list of outlet names in this category],
+            "bias category 3": [list of outlet names in this category],
+            "bias category 4": [list of outlet names in this category],
+            "unbiased": [list of outlet names that are generally neutral]
+          },
+          "descriptions": {
+            "bias category 1": "A concise description of what this category represents",
+            "bias category 2": "A concise description of what this category represents",
+            "bias category 3": "A concise description of what this category represents",
+            "bias category 4": "A concise description of what this category represents",
+            "unbiased": "A concise description of what this category represents"
+          },
+          "reasoning": "A brief explanation of your overall categorization approach"
+        }
+        
+        The number of bias categories can vary based on the query and news sources - create as many distinct categories as needed to accurately represent the different perspectives. You are not limited to just 1 or 2 bias categories - use as many as necessary.
+        
+        Replace "bias category 1", "bias category 2", etc. with meaningful names that describe the bias types you've identified.
+        Be comprehensive and put every outlet in exactly one category.
+        IMPORTANT: You MUST name one category exactly "unbiased" (lowercase) without any variation.
+        """
+        
+        # Use the original query directly
+        corrected_query = query
+        
+        # Prepare input for Gemini
+        input_text = f"Query: {corrected_query}\n\nNews Sources:\n" + "\n".join(outlet_names)
+        #print(input_text)
+        # Initialize Gemini client and generate analysis
+        model = genai.GenerativeModel(model_name)
+        
+        generation_config = genai.GenerationConfig(
+            temperature=0.1,  # Lower temperature for more deterministic results
+        )
+        
+        response = model.generate_content(
+            f"{bias_analysis_prompt}\n\n{input_text}",
+            generation_config=generation_config
+        )
+        
+        # Parse the JSON response
+        response_text = response.text
+        json_match = re.search(r'{[\s\S]*}', response_text)
+        
+        if json_match:
+            parsed_response = json.loads(json_match.group(0))
+            
+            # Handle the new JSON structure with categories and descriptions
+            bias_analysis = {}
+            category_descriptions = {}
+            
+            # Extract categories and descriptions from the new format
+            if 'categories' in parsed_response:
+                # New format
+                categories = parsed_response.get('categories', {})
+                category_descriptions = parsed_response.get('descriptions', {})
+                reasoning = parsed_response.get('reasoning', 'No reasoning provided')
+                
+                # Make sure one category is exactly named "unbiased"
+                # If there's a similar category (like "neutral"), rename it to "unbiased"
+                has_unbiased = "unbiased" in categories
+                if not has_unbiased:
+                    similar_category = None
+                    for cat in list(categories.keys()):
+                        if cat.lower() in ["neutral", "center", "balanced", "objective", "impartial"]:
+                            similar_category = cat
+                            break
+                    
+                    # Rename the similar category to "unbiased" if found
+                    if similar_category:
+                        categories["unbiased"] = categories.pop(similar_category)
+                        if similar_category in category_descriptions:
+                            category_descriptions["unbiased"] = category_descriptions.pop(similar_category)
+                
+                # Copy categories to the top level for backward compatibility
+                for category, outlets in categories.items():
+                    bias_analysis[category] = outlets
+            else:
+                # Old format for backward compatibility
+                for key, value in parsed_response.items():
+                    if key != "reasoning":
+                        bias_analysis[key] = value
+                reasoning = parsed_response.get('reasoning', 'No reasoning provided')
+            
+            # Add reasoning
+            bias_analysis["reasoning"] = reasoning
+            
+            # Add descriptions to the analysis result
+            bias_analysis["descriptions"] = category_descriptions
+            
+            # Print bias categories
+            print("\nBias Analysis Results:")
+            # Print information about each category
+            for key, values in bias_analysis.items():
+                if key not in ["reasoning", "descriptions"]:
+                    print(f"{key}: {len(values)} sources")
+            
+            print(f"\nReasoning: {bias_analysis.get('reasoning', 'No reasoning provided')}")
+            
+            return bias_analysis
+        else:
+            print("⚠️ Could not parse bias analysis response from Gemini.")
+            # Return an empty analysis with at least unbiased category if parsing fails
+            return {
+                "unbiased": [],
+                "reasoning": "Failed to analyze bias"
+            }
+    
+    except Exception as e:
+        print(f"⚠️ Error in bias analysis module: {e}")
+        # Return an empty analysis with at least unbiased category if an error occurs
+        return {
+            "unbiased": [],
+            "reasoning": f"Error in analysis: {str(e)}"
+        }
+
+
+def categorize_and_rank_by_bias(query, normalized_articles, bias_analysis, ranker, min_threshold):
+    """
+    Categorizes articles by bias category and creates embeddings for each category.
+    
+    Args:
+        query (str): The original user query
+        normalized_articles (list): List of normalized article dictionaries
+        bias_analysis (dict): The bias analysis results
+        ranker: The ArticleRanker instance
+        min_threshold (float): Minimum similarity threshold
+        
+    Returns:
+        dict: Dictionary containing ranked articles by category
+    """
+    # Get number of articles per category from environment variable
+    top_n_per_category = int(os.getenv('TOP_N_PER_CATEGORY', 5))
+    
+    # Extract the category names from the bias analysis
+    categories = []
+    for key in bias_analysis.keys():
+        if key not in ["reasoning", "descriptions"]:
+            categories.append(key)
+    
+    # Initialize dictionaries for categorized articles
+    categorized_articles = {}
+    for category in categories:
+        categorized_articles[category] = []
+    
+    # Categorize articles based on their source
+    for article in normalized_articles:
+        # Extract source name (handling both object and string formats)
+        if isinstance(article['source'], dict):
+            source_name = article['source'].get('name', '')
+        else:
+            source_name = article['source']
+        
+        # Check each category to see if this source belongs to it
+        for category in categories:
+            if source_name in bias_analysis.get(category, []):
+                categorized_articles[category].append(article)
+                break
+    
+    # Create separate embeddings for each category
+    category_rankings = {}
+    
+    for category, articles in categorized_articles.items():
+        if not articles:
+            category_rankings[category] = []
+            continue
+            
+        print(f"Creating embeddings for {len(articles)} articles in '{category}' category...")
+        
+        # Prepare article texts for this category - ONLY USE TITLES
+        category_texts = [article['title'] for article in articles]
+        
+        try:
+            # Create embeddings for this category
+            query_embedding, category_embeddings = ranker.create_embeddings(query, category_texts)
+            
+            # Calculate similarities
+            similarities = ranker.calculate_similarities(query_embedding, category_embeddings)
+            
+            # Get top articles for this category
+            top_indices = ranker.get_top_articles(
+                similarities, 
+                articles, 
+                min(top_n_per_category, len(articles)), 
+                min_threshold
+            )
+            
+            # Format results for this category
+            category_rankings[category] = ranker.format_results(top_indices, similarities, articles)
+            
+            # No need to print articles here since they will be printed in main.py
+        
+        except Exception as e:
+            print(f"⚠️ Error ranking articles for '{category}' category: {e}")
+            category_rankings[category] = []
+    
+    return category_rankings
+
+
+def generate_summary(query, normalized_articles, category_rankings, model_name):
+    """
+    Generates a summary using articles from all categories, clearly identifying each category's sources.
+    
+    Args:
+        query (str): The original user query
+        normalized_articles (list): List of normalized article dictionaries
+        category_rankings (dict): The ranked articles by category
+        model_name (str): The name of the Gemini model to use
+        
+    Returns:
+        str: The generated summary
+    """
+    # Extract the reasoning from category_rankings if available
+    reasoning = category_rankings.get("reasoning", "No reasoning provided") if isinstance(category_rankings, dict) else "No reasoning provided"
+    
+    # Check if we have any articles for summarization
+    if not category_rankings or all(not articles for category, articles in category_rankings.items() 
+                                if category not in ["descriptions", "reasoning"]):
+        print("No articles available for summarization.")
+        return "No articles available for summarization."
+    
+    # Define system prompt for summarization
+    summarization_prompt = """
+    You are an expert news summarizer focused on factual reporting. Your task is to create a concise, factual summary based on multiple news sources from different bias categories.
+    
+    The articles provided will be clearly labeled with their bias category. You will receive articles from different perspectives:
+    Articles from the "unbiased" category are generally considered neutral and factual
+    Articles from other categories may represent specific perspectives or biases
+    
+    Guidelines:
+    1. Focus primarily on verifiable facts that appear across multiple sources
+    2. Highlight areas of consensus across sources from different categories
+    3. Note significant differences in how different categories report on the same events
+    4. Maintain neutral language in your summary despite potential bias in the sources
+    5. Include relevant dates, figures, and key details
+    6. Prioritize information that directly answers the user's query
+    7. Acknowledge different perspectives when they exist
+    
+    IMPORTANT FORMAT INSTRUCTION: Do not use any symbols such as hash (#), asterisk (*), hyphen (-), underscore (_), or any other special characters in your output. Use plain text without any special formatting symbols.
+    
+    Structure your response in these sections:
+    1. SUMMARY A 3 to 5 sentence factual answer to the query that balances all perspectives
+    2. KEY FACTS 4 to 6 numbered points with the most important verified information (use numbers only, no symbols)
+    3. DIFFERENT PERSPECTIVES Brief explanation of how different sources frame the issue
+    4. SOURCES BY CATEGORY 
+       Group sources under their respective categories (UNBIASED SOURCES, CATEGORY 1 SOURCES, etc.)
+       Under each category heading, list UP TO 5 URLs of sources from that category
+       Number sources starting from 1 within EACH category (each category has its own 1 to 5 numbering)
+       Include only the source name, date, and URL for each source
+       Format: 1. source.com (date) URL https://source.com/article
+    
+    IMPORTANT 
+    Show each category as a separate heading with the category name in ALL CAPS
+    List all sources from the same category together under their category heading
+    Each category should have its OWN numbering from 1 to 5 (do NOT number continuously across categories)
+    Include URLs for each source, clearly labeled
+    Show up to 5 sources PER CATEGORY (not 5 total)
+    DO NOT use any special characters or symbols such as hash (#), asterisk (*), hyphen (-), underscore (_)
+    
+    Be accurate, concise, and provide a balanced view that acknowledges different perspectives.
+    """
+    
+    # We'll limit to a maximum of 30 articles total (to avoid overloading Gemini)
+    # but we'll make sure each category is represented
+    article_info = []
+    article_number = 1
+    max_articles_total = 30
+    
+    # Count the number of non-empty categories
+    valid_categories = [cat for cat in category_rankings.keys() 
+                       if cat not in ["descriptions", "reasoning"] and category_rankings[cat]]
+    
+    # Calculate how many articles to take from each category to maintain balance
+    # Ensure we try to get at least 5 per category when possible
+    articles_per_category = min(10, max(5, max_articles_total // len(valid_categories))) if valid_categories else 0
+    
+    # Process articles from each category
+    for category, articles in category_rankings.items():
+        # Skip non-category keys
+        if category in ["descriptions", "reasoning"]:
+            continue
+            
+        # Skip empty categories
+        if not articles:
+            continue
+            
+        # Get limited articles for this category
+        top_articles = articles[:min(articles_per_category, len(articles))]
+        
+        # Add category header
+        article_info.append(f"\n===== ARTICLES FROM {category.upper()} CATEGORY =====\n\n")
+        
+        # Extract article information for this category
+        for article in top_articles:
+            # Find the full article data from normalized_articles
+            for full_article in normalized_articles:
+                if full_article['url'] == article['url']:
+                    # Extract source name (handling both object and string formats)
+                    if isinstance(full_article['source'], dict):
+                        source_name = full_article['source'].get('name', '')
+                    else:
+                        source_name = full_article['source']
+                    
+                    # Use the appropriate date field
+                    published_date = full_article.get('publishedAt', full_article.get('published_at', ''))
+                    
+                    # Get description content, ensuring we have at least some text
+                    description = full_article.get('description', '')
+                    if not description and 'content' in full_article:
+                        description = full_article['content']
+                    if not description:
+                        description = "No content available. Using title only."
+                    
+                    article_info.append(
+                        f"ARTICLE {article_number} ({category.upper()}):\n"
+                        f"Title: {full_article['title']}\n"
+                        f"Source: {source_name}\n"
+                        f"URL: {full_article['url']}\n"
+                        f"Date: {published_date}\n"
+                        f"Content: {description}\n\n"
+                    )
+                    article_number += 1
+                    break
+            else:
+                # If we didn't find the full article, use what we have from the ranked article
+                article_info.append(
+                    f"ARTICLE {article_number} ({category.upper()}):\n"
+                    f"Title: {article['title']}\n"
+                    f"Source: {article['source']}\n"
+                    f"URL: {article['url']}\n"
+                    f"Date: {article['published_at']}\n"
+                    f"Content: No detailed content available.\n\n"
+                )
+                article_number += 1
+    
+    # Prepare input for Gemini
+    input_text = f"""USER QUERY: {query}
+
+IMPORTANT INSTRUCTIONS:
+- Group sources by their categories with clear headings (e.g., UNBIASED SOURCES, CATEGORY 1 SOURCES)
+- List UP TO 5 URLs under EACH category heading
+- Each category should have its OWN numbering from 1-5 (restart at 1 for each category)
+- Show up to 5 sources PER CATEGORY (not 5 total)
+- Format each source as: #1. source.com (date) - URL: https://source.com/article
+
+{''.join(article_info)}"""
+    
+    try:
+        # Initialize Gemini client and generate summary
+        model = genai.GenerativeModel(model_name)
+        
+        generation_config = genai.GenerationConfig(
+            temperature=0.2,  # Moderate temperature for factual but natural summary
+        )
+        
+        # Get additional instructions to format the output with clear source categorization
+        post_processing_instructions = """
+Please ensure your final output follows these formatting guidelines:
+1. SUMMARY section should be at the top
+2. KEY FACTS section should follow the summary
+3. DIFFERENT PERSPECTIVES section should be after key facts
+4. SOURCES BY CATEGORY section should:
+   - Group sources by their categories (e.g., UNBIASED SOURCES, CATEGORY 1 SOURCES, etc.)
+   - List each category as a separate heading in ALL CAPS
+   - Show UP TO 5 URLs clearly under each category heading
+   - Each category should have its OWN numbering from 1-5 (restart at 1 for each category)
+   - Show the MOST RELEVANT sources from each category
+"""
+
+        # Prepare the prompt with formatting instructions
+        prompt_with_formatting = f"{summarization_prompt}\n\n{post_processing_instructions}\n\n{input_text}"
+        
+        response = model.generate_content(
+            prompt_with_formatting,
+            generation_config=generation_config
+        )
+        
+        # Format the response with consistent styling similar to the input query display in UI
+        summary_text = response.text
+        
+        # Create formatted summary with consistent styling
+        formatted_summary = f"""
+MULTI-PERSPECTIVE FACTUAL SUMMARY:
+
+{summary_text}
+
+ANALYSIS REASONING:
+
+{reasoning}
+
+"""
+        
+        # Return the formatted summary
+        return formatted_summary
+        
+    except Exception as e:
+        error_msg = f"⚠️ Error generating summary: {e}"
+        print(error_msg)
+        return error_msg

check_models.py

@@ -0,0 +1,21 @@
+"""
+Check available models in Google Generative AI.
+"""
+
+import os
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Set up the Gemini API with the API key
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
+if not GEMINI_API_KEY:
+    raise ValueError("GEMINI_API_KEY environment variable not set")
+
+genai.configure(api_key=GEMINI_API_KEY)
+
+# List available models
+for model in genai.list_models():
+    print(model.name)

gdelt_api.py

@@ -0,0 +1,193 @@
+"""
+gdelt_api.py - Module for interacting with the GDELT API
+
+This module provides functions for fetching articles from GDELT
+and filtering by trusted domains.
+"""
+
+import os
+import requests
+import datetime
+from urllib.parse import urlparse
+from dotenv import load_dotenv
+
+# Import the whitelist from the separate module
+from whitelisted_domains import WHITELISTED_DOMAINS
+
+
+def fetch_articles_from_gdelt(query):
+    """
+    Fetch news articles from GDELT API.
+    
+    Args:
+        query (str): The news query to search for (can be structured GDELT query)
+        
+    Returns:
+        list: List of article dictionaries, or empty list if no results or error
+    """
+    try:
+        # Construct the API URL with the query
+        base_url = "https://api.gdeltproject.org/api/v2/doc/doc"
+        
+        # Parse the query to separate main query from other parameters
+        params = {
+            'format': 'json',
+            'maxrecords': int(os.getenv('MAX_ARTICLES_PER_QUERY', 250))
+        }
+        
+        # If the query has multiple parameters (separated by &)
+        if '&' in query:
+            parts = query.split('&')
+            for part in parts:
+                if '=' in part:
+                    key, value = part.split('=', 1)
+                    params[key] = value
+                elif part.startswith('query='):
+                    params['query'] = part[6:]  # Remove 'query='
+                else:
+                    # If it's just a query without the query= prefix
+                    if 'query' not in params:
+                        params['query'] = part
+        else:
+            # It's just a simple query
+            if query.startswith('query='):
+                params['query'] = query[6:]  # Remove 'query='
+            else:
+                params['query'] = query
+        
+        # Convert params to query string
+        query_string = "&".join([f"{k}={requests.utils.quote(str(v))}" for k, v in params.items()])
+        url = f"{base_url}?{query_string}"
+        
+        print(f"DEBUG - Requesting URL: {url}")
+        
+        # Make the request
+        response = requests.get(url, timeout=30)
+        
+        # Check if the request was successful
+        if response.status_code == 200:
+            data = response.json()
+            
+            # GDELT API returns articles in the 'articles' field
+            if 'articles' in data:
+                return data['articles']
+        
+        return []
+        
+    except Exception as e:
+        print(f"⚠️ Error fetching articles from GDELT: {e}")
+        return []
+
+
+def is_whitelisted_domain(url):
+    """
+    Check if the URL belongs to a whitelisted domain.
+    
+    Args:
+        url (str): The URL to check
+        
+    Returns:
+        bool: True if the domain is whitelisted, False otherwise
+    """
+    try:
+        domain = urlparse(url).netloc
+        
+        # Handle subdomains by checking if any whitelisted domain is a suffix
+        return any(domain.endswith(trusted_domain) for trusted_domain in WHITELISTED_DOMAINS)
+    except:
+        return False
+
+
+def format_timestamp(timestamp_str):
+    """
+    Format a GDELT timestamp string to a more user-friendly format.
+    
+    Args:
+        timestamp_str (str): Timestamp string in GDELT format (e.g., "20250829T173000Z")
+        
+    Returns:
+        str: Formatted timestamp (e.g., "Aug 29, 2025 17:30")
+    """
+    if not timestamp_str:
+        return ""
+        
+    try:
+        # Handle common GDELT timestamp format
+        if "T" in timestamp_str and len(timestamp_str) >= 15:
+            # Parse YYYYMMDDTHHMMSSZ format
+            year = timestamp_str[0:4]
+            month = timestamp_str[4:6]
+            day = timestamp_str[6:8]
+            hour = timestamp_str[9:11]
+            minute = timestamp_str[11:13]
+            
+            # Convert month number to month name
+            month_name = datetime.datetime.strptime(month, "%m").strftime("%b")
+            
+            return f"{month_name} {int(day)}, {year} {hour}:{minute}"
+        else:
+            # Return original if not in expected format
+            return timestamp_str
+    except Exception as e:
+        print(f"Error formatting timestamp {timestamp_str}: {e}")
+        return timestamp_str
+
+
+def filter_by_whitelisted_domains(articles):
+    """
+    Filter articles to only include those from trusted domains.
+    
+    Args:
+        articles (list): List of article dictionaries
+        
+    Returns:
+        list: Filtered list of article dictionaries
+    """
+    if not articles:
+        return []
+    
+    trusted_articles = []
+    total_articles = len(articles)
+    
+    for article in articles:
+        if 'url' in article and is_whitelisted_domain(article['url']):
+            trusted_articles.append(article)
+    
+    filtered_count = total_articles - len(trusted_articles)
+    print(f"Domain filtering: {filtered_count} non-whitelisted articles removed, {len(trusted_articles)} whitelisted articles kept")
+    
+    return trusted_articles
+
+
+def normalize_gdelt_articles(articles):
+    """
+    Normalize GDELT article format to match the expected format in the rest of the application.
+    
+    Args:
+        articles (list): List of GDELT article dictionaries
+        
+    Returns:
+        list: List of normalized article dictionaries
+    """
+    normalized_articles = []
+    
+    for article in articles:
+        # Extract domain from URL for source name if not available
+        source_name = article.get('sourcename', '')
+        if not source_name and 'url' in article:
+            domain = urlparse(article['url']).netloc
+            source_name = domain.replace('www.', '')
+        
+        # Format the timestamp for better readability
+        raw_timestamp = article.get('seendate', '')
+        formatted_timestamp = format_timestamp(raw_timestamp)
+        
+        normalized_articles.append({
+            'title': article.get('title', ''),
+            'description': article.get('seentext', ''),
+            'url': article.get('url', ''),
+            'publishedAt': formatted_timestamp,
+            'source': {'name': source_name}
+        })
+    
+    return normalized_articles

gdelt_query_builder.py

@@ -0,0 +1,202 @@
+"""
+gdelt_query_builder.py - Module for building GDELT queries using Gemini API
+
+This module uses Google's Gemini API to transform natural language queries
+into structured GDELT query format.
+"""
+
+import os
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Set up the Gemini API with the API key from environment variables
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
+if not GEMINI_API_KEY:
+    raise ValueError("GEMINI_API_KEY environment variable not set. Please add it to your .env file.")
+
+# Initialize the Gemini client
+genai.configure(api_key=GEMINI_API_KEY)
+
+# Get the model name from environment variables or use default
+GEMINI_MODEL = os.getenv('GEMINI_MODEL', 'gemini-2.5-flash')
+
+# Define the system prompt for Gemini
+SYSTEM_PROMPT = """
+You are a query builder for the GDELT 2.0 DOC API.
+Your task is to take the user's natural language request and produce TEN different variations of the query for the GDELT API. Use simple English words to create variations.
+
+IMPORTANT: First, check if the query contains inappropriate content such as:
+- Pornography or sexually explicit content
+
+
+If the query contains ANY of the above, respond EXACTLY with the string: 
+"INAPPROPRIATE_QUERY_DETECTED"
+
+Otherwise, proceed with the following rules:
+
+Rules:
+1. IMPORTANT: Always keep the query variations in the SAME LANGUAGE as the user's original query.
+2. Correct spelling mistakes in the user input before processing.
+3. Remove all words with length less than or equal to 2 characters ONLY if they don't affect meaning.
+4. ONLY use AND operators between terms. DO NOT use OR or NOT operators.
+5. Create TWO TYPES of variations:
+   a. For the first 5 variations: Create journalistic style queries with verbs and complete phrases (e.g., "announced sanctions", "threatens military action")
+   b. For the last 5 variations: Focus ONLY on organizations, entities, and relevant nouns WITHOUT any verbs or phrases of speech (e.g., "European Union" AND "Russia" AND "sanctions")
+6. CRITICAL: All terms in the main query part (between AND operators) MUST have a minimum length of 5 characters. This rule does NOT apply to sourcecountry, sourceregion, and timestamp parameters.
+   - Replace short terms (< 5 chars) with equivalent longer terms (e.g., "UK" → "United Kingdom", "US" → "United States", "EU" → "Europe")
+   - For common short words with no longer alternative, add context words to make them more specific
+7. Contextual understanding:
+   - ALWAYS analyze the query for implied countries, regions, people, or events that suggest a location
+   - For people (e.g., "Biden", "Putin", "Modi"), infer their associated country
+   - For events (e.g., "Olympics in Paris", "Earthquake in Japan"), extract the location
+   - For organizations (e.g., "EU Parliament", "Kremlin"), map to their appropriate region
+7. Country and region parameters:
+   - Always include sourcecountry and/or sourceregion when you can infer them from context
+   - If user mentions a country, include it as: sourcecountry=<ISO code>
+   - If user mentions a region, include it as: sourceregion=<region code>
+   - For Europe use: sourceregion=EU (not a country code)
+   - For implicit locations (e.g., "Eiffel Tower" → France), add the appropriate country code
+8. Time range detection:
+   - Analyze for any time-related terms ("yesterday", "last week", "June 2025")
+   - Include startdatetime and enddatetime for any time reference (format YYYYMMDDHHMMSS)
+   - For relative times like "last week" or "recent", calculate actual date ranges
+9. Main query construction:
+   - Always format as: query=<search terms>
+   - For exact phrases use double quotes: query="climate change"
+   - Connect concepts with AND ONLY: query="climate change" AND "global warming"
+   - Each query should be well-formed with proper placement of operators and quotes
+10. Language preservation:
+   - If the user's query is in English, all variations must be in English
+   - If the user's query is in Spanish, all variations must be in Spanish
+   - If the user's query is in French, all variations must be in French
+   - Always maintain the original language of the user's query in all variations
+11. Output format:
+   - Return EXACTLY ten query variations, separated by ||| (three pipe symbols)
+   - For the first 5 variations, focus on journalistic style with complete phrases
+   - For the last 5 variations, focus ONLY on organizations, entities, locations, and relevant nouns WITHOUT any verbs or phrases of speech
+   - Example for entity-only variations: query="United Nations" AND "climate change" AND "Paris"
+   - Each query should be a complete, valid GDELT query string
+   - Format each query correctly with query= at the beginning and & between parameters
+   - Do not explain your choices, just return the ten queries
+
+Examples:
+- Input: "Did a tsunami really happen in Japan yesterday?"
+  Output: query="tsunami" AND "Japan"&sourcecountry=JP&startdatetime=20250903000000&enddatetime=20250903235959 ||| query="natural disaster" AND "Japan"&sourcecountry=JP&startdatetime=20250903000000&enddatetime=20250903235959 ||| query="earthquake" AND "tsunami" AND "Japan"&sourcecountry=JP&startdatetime=20250903000000&enddatetime=20250903235959
+
+- Input: "Is it true that there was an explosion near the Eiffel Tower?"
+  Output: query="explosion" AND "Eiffel Tower"&sourcecountry=FR&sourceregion=EU ||| query="incident" AND "Eiffel Tower" AND "Paris"&sourcecountry=FR&sourceregion=EU ||| query="security" AND "Eiffel Tower" AND "explosion"&sourcecountry=FR&sourceregion=EU
+
+- Input: "Did Biden announce new sanctions against Russia last week?"
+  Output: query="Biden" AND "sanctions" AND "Russia"&sourcecountry=US&startdatetime=20250828000000&enddatetime=20250903235959 ||| query="United States" AND "sanctions" AND "Russia"&sourcecountry=US&startdatetime=20250828000000&enddatetime=20250903235959 ||| query="Biden" AND "economic measures" AND "Russia"&sourcecountry=US&startdatetime=20250828000000&enddatetime=20250903235959
+  
+- Input: "¿Hubo una manifestación en Madrid ayer?"
+  Output: query="manifestación" AND "Madrid"&sourcecountry=ES&startdatetime=20250903000000&enddatetime=20250903235959 ||| query="protesta" AND "Madrid"&sourcecountry=ES&startdatetime=20250903000000&enddatetime=20250903235959 ||| query="manifestación" AND "España" AND "Madrid"&sourcecountry=ES&startdatetime=20250903000000&enddatetime=20250903235959
+
+- Input: "Was a new law on AI passed in UK?"
+  Output: query="legislation" AND "artificial intelligence" AND "United Kingdom"&sourcecountry=GB ||| query="regulation" AND "artificial intelligence" AND "United Kingdom"&sourcecountry=GB ||| query="parliament" AND "artificial intelligence" AND "United Kingdom"&sourcecountry=GB
+"""
+
+
+def generate_query(user_input: str) -> list:
+    """
+    Generate ten structured GDELT queries from natural language input using Gemini API.
+    
+    Args:
+        user_input (str): The user's natural language query
+        
+    Returns:
+        list: List of ten structured GDELT query variations or a list with a single
+              inappropriate content message if the query contains sensitive topics
+    """
+    try:
+        # Create the chat with system prompt and user input
+        combined_prompt = f"{SYSTEM_PROMPT}\n\nUser request: {user_input}"
+        
+        # Generate content with the specified model
+        model = genai.GenerativeModel(GEMINI_MODEL)
+        
+        # Set generation config to disable thinking
+        generation_config = genai.GenerationConfig(
+            temperature=0.3,  # Slightly higher temperature for more variation
+        )
+        
+        response = model.generate_content(
+            combined_prompt,
+            generation_config=generation_config
+        )
+        
+        # Extract the response text
+        response_text = response.text.strip()
+        
+        # Check if the model detected inappropriate content
+        if response_text == "INAPPROPRIATE_QUERY_DETECTED":
+            print(f"⚠️ Inappropriate query detected: '{user_input}'")
+            # Return a special marker that will be detected in main.py
+            return ["INAPPROPRIATE_QUERY"]
+        
+        # Split the response by the separator
+        query_variations = response_text.split('|||')
+        
+        # Clean and format each query variation
+        formatted_queries = []
+        for i, query in enumerate(query_variations):
+            query = query.strip()
+            
+            # Ensure query format is correct - add "query=" if needed
+            if not (query.startswith('query=') or 
+                    'sourcecountry=' in query or 
+                    'sourceregion=' in query or
+                    'startdatetime=' in query):
+                # Add query= prefix if not dealing with just filter parameters
+                query = f'query={query}'
+            
+            formatted_queries.append(query)
+        
+        # If we don't have exactly 10 queries, duplicate or trim as needed
+        while len(formatted_queries) < 10:
+            formatted_queries.append(formatted_queries[0])
+        
+        if len(formatted_queries) > 10:
+            formatted_queries = formatted_queries[:10]
+        
+        # Log the transformation only once
+        print(f"Original input: '{user_input}'")
+        for i, query in enumerate(formatted_queries):
+            print(f"Query variation {i+1}: '{query}'")
+        
+        return formatted_queries
+        
+    except Exception as e:
+        if "429" in str(e):
+            print(f"⚠️ Rate limit exceeded for Gemini API. Using original query. Details: {e}")
+        elif "404" in str(e) and "models" in str(e):
+            print(f"⚠️ Model not found. Please check available models. Details: {e}")
+        elif "400" in str(e) and "API key" in str(e):
+            print(f"⚠️ Invalid API key. Please check your GEMINI_API_KEY in .env file. Details: {e}")
+        else:
+            print(f"⚠️ Error generating structured query: {e}")
+        
+        # Format the original query with quotes for GDELT for all ten variations
+        fallback_query = f'query="{user_input}"'
+        return [fallback_query] * 10
+
+
+if __name__ == "__main__":
+    # Example usage
+    test_queries = [
+        "Latest news about climate change in Europe",
+        "Political developments in Ukraine last week",
+        "Economic impact of recent floods in Asia",
+        "Noticias sobre cambio climático en España"  # Spanish query
+    ]
+    
+    print("\nGDELT Query Builder - Example Usage\n")
+    for query in test_queries:
+        print(f"\nTesting query: {query}")
+        query_variations = generate_query(query)
+        for i, variation in enumerate(query_variations):
+            print(f"Variation {i+1}: {variation}")
+        print("-" * 80)

google_search.py

@@ -0,0 +1,64 @@
+import requests
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Get SerpAPI key from environment variables
+API_KEY = os.getenv('SERPAPI_KEY')
+if not API_KEY:
+    raise ValueError("SERPAPI_KEY environment variable not set. Please add it to your .env file.")
+
+def google_search(query, num_results=25):
+    """
+    Search Google for articles related to the query using SerpAPI.
+    
+    Args:
+        query (str): The search query
+        num_results (int): Number of results to return
+        
+    Returns:
+        list: List of article dictionaries with title, snippet, and URL
+    """
+    url = "https://serpapi.com/search"
+    params = {
+        "engine": "google",   # search engine
+        "q": query,           # search query
+        "api_key": API_KEY,   # your key
+        "num": num_results    # number of results
+    }
+    
+    try:
+        response = requests.get(url, params=params)
+        response.raise_for_status()  # Raise exception for HTTP errors
+        results = response.json()
+
+        output = []
+        for item in results.get("organic_results", []):
+            # Format the results to match GDELT article format for consistency
+            article = {
+                "title": item.get("title", "No title"),
+                "snippet": item.get("snippet", "No description available"),
+                "url": item.get("link", ""),
+                "source": {
+                    "name": item.get("source", "Google Search")
+                },
+                "publishedAt": "",  # No date information in the API response
+                "origin": "google_search"  # Add origin to track source
+            }
+            output.append(article)
+            
+        print(f"Found {len(output)} results from Google Search")
+        return output
+        
+    except Exception as e:
+        print(f"Error with Google Search API: {e}")
+        return []
+
+# Example usage
+if __name__ == "__main__":
+    query = "GM stopped operations in India"
+    search_results = google_search(query)
+    for r in search_results:
+        print(f"{r['title']}\n{r['snippet']}\n{r['link']}\n")

main.py

@@ -0,0 +1,345 @@
+#!/home/tom/miniconda3/envs/fake_news_detection/bin/python
+"""
+main.py - Server for the Fake News Detection system
+
+This script creates a Flask server that exposes API endpoints to:
+1. Take user input (news query) from the UI
+2. Process the request through the fake news detection pipeline
+3. Return the results to the UI for display
+"""
+
+import os
+import json
+import time
+from dotenv import load_dotenv
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+
+# Import required functions from modules
+from gdelt_api import (
+    fetch_articles_from_gdelt,
+    filter_by_whitelisted_domains,
+    normalize_gdelt_articles
+)
+from ranker import ArticleRanker
+from gdelt_query_builder import generate_query, GEMINI_MODEL
+import bias_analyzer
+from google_search import google_search
+
+# Global variable for embedding model caching across requests
+print("Preloading embedding model for faster request processing...")
+# Preload the embedding model at server startup
+global_ranker = ArticleRanker()
+
+
+# The function has been removed since bias category descriptions are provided directly by the Gemini model
+# and stored in the bias_analysis["descriptions"] dictionary
+
+
+def format_results(query, ranked_articles):
+    """
+    Format the ranked results in a structured way for the UI.
+    
+    Args:
+        query (str): The original query
+        ranked_articles (list): List of ranked article dictionaries
+        
+    Returns:
+        dict: Dictionary with formatted results
+    """
+    result = {}
+    
+    if not ranked_articles:
+        result = {
+            "status": "no_results",
+            "message": "⚠️ No news found. Possibly Fake.",
+            "details": "No reliable sources could verify this information.",
+            "articles": []
+        }
+    else:
+        # Get display configuration from environment variables
+        show_scores = os.getenv('SHOW_SIMILARITY_SCORES', 'true').lower() == 'true'
+        show_date = os.getenv('SHOW_PUBLISH_DATE', 'true').lower() == 'true'
+        show_url = os.getenv('SHOW_URL', 'true').lower() == 'true'
+        
+        formatted_articles = []
+        for article in ranked_articles:
+            formatted_article = {
+                "rank": article['rank'],
+                "title": article['title'],
+                "source": article['source']
+            }
+            
+            if show_scores:
+                formatted_article["similarity_score"] = round(article['similarity_score'], 4)
+                
+            if show_url:
+                formatted_article["url"] = article['url']
+                
+            if show_date:
+                formatted_article["published_at"] = article['published_at']
+                
+            formatted_articles.append(formatted_article)
+        
+        result = {
+            "status": "success",
+            "message": f"✅ Found {len(ranked_articles)} relevant articles for: '{query}'",
+            "articles": formatted_articles,
+            "footer": "If the news matches these reliable sources, it's likely true. If it contradicts them or no sources are found, it might be fake."
+        }
+    
+    return result
+
+
+def remove_duplicates(articles):
+    """
+    Remove duplicate articles based on URL.
+    
+    Args:
+        articles (list): List of article dictionaries
+        
+    Returns:
+        list: List with duplicate articles removed
+    """
+    unique_urls = set()
+    unique_articles = []
+    
+    for article in articles:
+        if article['url'] not in unique_urls:
+            unique_urls.add(article['url'])
+            unique_articles.append(article)
+    
+    return unique_articles
+
+
+# This function has been removed since Gemini is a cloud API service
+# that does not require local caching - models are instantiated as needed
+
+
+def main():
+    """Main function to run the fake news detection pipeline as a server."""
+    # Load environment variables
+    load_dotenv()
+    
+    # Create Flask app
+    app = Flask(__name__, static_folder='static')
+    CORS(app)  # Enable CORS for all routes
+    
+    @app.route('/static/')
+    def index():
+        """Serve the main page."""
+        return app.send_static_file('front.html')
+
+    
+    @app.route('/api/detect', methods=['POST'])
+    def detect_fake_news():
+        """API endpoint to check if news is potentially fake."""
+        # Start timing the request processing
+        start_time = time.time()
+        
+        data = request.json
+        query = data.get('query', '')
+        
+        if not query:
+            return jsonify({
+                "status": "error",
+                "message": "Please provide a news statement to verify."
+            })
+        
+        # =====================================================
+        # 1. Input Handling
+        # =====================================================
+        # Generate three variations of the query using Gemini
+        query_variations = generate_query(query)
+        
+        # Check if the query was flagged as inappropriate
+        if query_variations == ["INAPPROPRIATE_QUERY"]:
+            return jsonify({
+                "status": "error",
+                "message": "I cannot provide information on this topic as it appears to contain sensitive or inappropriate content."
+            })
+        
+        # =====================================================
+        # 2. Data Fetching
+        # =====================================================
+        # Fetch articles from GDELT API for each query variation
+        all_articles = []
+        
+        # First, fetch Google search results using the original query
+        # print(f"Fetching Google search results for: {query}")
+        # google_results = google_search(query, num_results=25)
+        # if google_results:
+        #     all_articles.extend(google_results)
+        #     print(f"Added {len(google_results)} Google search results to articles")
+        
+        # Then fetch GDELT results for each query variation
+        for query_var in query_variations:
+            articles = fetch_articles_from_gdelt(query_var)
+            if articles:
+                all_articles.extend(articles)
+        
+        # After the loop, check if any articles were found
+        if not all_articles:
+            return jsonify({
+                "status": "no_results",
+                "message": "No articles found on this topic.",
+                "details": "No reliable sources could be found covering this information.",
+                "articles": []
+            })
+        
+        # Store unique articles in a set to ensure uniqueness
+        unique_articles = remove_duplicates(all_articles)
+        
+        # Apply domain whitelist filtering if enabled in .env
+        use_whitelist_only = os.getenv('USE_WHITELIST_ONLY', 'false').lower() == 'true'
+        if use_whitelist_only:
+            print(f"Filtering articles to only include whitelisted domains...")
+            unique_articles = filter_by_whitelisted_domains(unique_articles)
+            print(f"After whitelist filtering: {len(unique_articles)} articles remain")
+        
+        # Normalize the articles to a standard format
+        normalized_articles = normalize_gdelt_articles(unique_articles)
+        
+        if not normalized_articles:
+            return jsonify(format_results(query, []))
+        
+        # =====================================================
+        # 3. Embedding & Ranking
+        # =====================================================
+        # Initialize the ranker with model from environment variable
+        model_name = os.getenv('SIMILARITY_MODEL', 'intfloat/multilingual-e5-base')
+        
+        # Use global ranker if it matches the requested model, otherwise create a new instance
+        if global_ranker.model_name == model_name:
+            ranker = global_ranker
+        else:
+            ranker = ArticleRanker(model_name)
+        
+        # Get TOP_K_ARTICLES from .env file
+        TOP_K_ARTICLES = int(os.getenv('TOP_K_ARTICLES', 250))
+        min_threshold = float(os.getenv('MIN_SIMILARITY_THRESHOLD', 0.1))
+        
+        # Prepare article texts for embedding
+        article_texts = [f"{article['title']} {article['description'] or ''}" for article in normalized_articles]
+        
+        # Create embeddings and calculate similarities
+        query_embedding, article_embeddings = ranker.create_embeddings(query, article_texts)
+        similarities = ranker.calculate_similarities(query_embedding, article_embeddings)
+        
+        # Get top articles based on similarity
+        top_indices = ranker.get_top_articles(similarities, normalized_articles, TOP_K_ARTICLES, min_threshold)
+        top_articles = ranker.format_results(top_indices, similarities, normalized_articles)
+        
+        # =====================================================
+        # 4. Bias Categorization
+        # =====================================================
+        # Extract outlet names from the TOP_K_ARTICLES
+        # In top_articles, the source is already extracted as a string
+        outlet_names = [article['source'] for article in top_articles]
+        unique_outlets = list(set(outlet_names))
+        print(f"Analyzing {len(unique_outlets)} unique news outlets for bias...")
+        
+        # Analyze bias using Gemini - send just the outlet names, not the whole articles
+        bias_analysis = bias_analyzer.analyze_bias(query, unique_outlets, GEMINI_MODEL)
+        
+        # =====================================================
+        # 5. Category Embeddings
+        # =====================================================
+        print("\n" + "=" * 80)
+        print("EMBEDDING VECTORS BY BIAS CATEGORY")
+        print("=" * 80)
+        
+        # Create embedding vectors for each bias category
+        # 1. Group articles based on their outlet's bias category
+        # 2. Create an embedding vector for each category using ONLY article titles
+        # 3. Rank articles within each category by similarity to query
+        category_rankings = bias_analyzer.categorize_and_rank_by_bias(
+            query, normalized_articles, bias_analysis, ranker, min_threshold
+        )
+        
+        # =====================================================
+        # 6. Top N Selection per Category
+        # =====================================================
+        # Get TOP_N_PER_CATEGORY from .env file (default: 5)
+        TOP_N_PER_CATEGORY = int(os.getenv('TOP_N_PER_CATEGORY', 5))
+        
+        # Get total counts of articles per category before filtering
+        category_article_counts = {
+            category: len(articles) 
+            for category, articles in category_rankings.items() 
+            if category not in ["descriptions", "reasoning"]
+        }
+        
+        # For each bias category, select the top N articles
+        # These are the most relevant articles within each bias perspective
+        filtered_category_rankings = {}
+        for category, articles in category_rankings.items():
+            # Skip non-category keys like "descriptions" or "reasoning"
+            if category in ["descriptions", "reasoning"]:
+                continue
+                
+            filtered_category_rankings[category] = articles[:TOP_N_PER_CATEGORY]
+            
+            # Only print if there are articles in this category
+            if len(filtered_category_rankings[category]) > 0:
+                print(f"\n===== Top {len(filtered_category_rankings[category])} articles from {category} category =====")
+                
+                # Print detailed information about each selected article
+                for i, article in enumerate(filtered_category_rankings[category], 1):
+                    print(f"Article #{i}:")
+                    print(f"  Title: {article['title']}")
+                    print(f"  Source: {article['source']}")
+                    print(f"  Similarity Score: {article['similarity_score']:.4f}")
+                    print(f"  Rank: {article['rank']}")
+                    print(f"  URL: {article['url']}")
+                    print(f"  Published: {article['published_at']}")
+                    print("-" * 50)
+        
+        # =====================================================
+        # 7. Summarization
+        # =====================================================
+        # Generate summary from articles in all categories
+        print("\nGenerating factual summary using top articles from all categories...")
+        
+        # Pass the original bias_analysis to include the reasoning in the summary
+        # We need to add the reasoning to filtered_category_rankings since that's what gets passed to generate_summary
+        filtered_category_rankings["reasoning"] = bias_analysis.get("reasoning", "No reasoning provided")
+        
+        # Call the bias_analyzer's generate_summary function with articles from all categories
+        summary = bias_analyzer.generate_summary(
+            query, 
+            normalized_articles, 
+            filtered_category_rankings, 
+            GEMINI_MODEL
+        )
+        
+        # Print the summary to terminal (already includes its own formatting)
+        print(summary)
+        
+        # Prepare response with ONLY the combined summary (reasoning already appended at end)
+        # Removed separate 'reasoning' key to avoid it showing at the top in the UI
+        result = {
+            "summary": summary
+        }
+        
+        return jsonify(result)
+    
+    @app.route('/api/health', methods=['GET'])
+    def health_check():
+        """API endpoint to check if the server is running."""
+        return jsonify({
+            "status": "ok", 
+            "message": "Fake News Detection API is running"
+        })
+    
+    # Get port from environment variable or use default 5000
+    port = int(os.getenv('PORT', 5000))
+    debug = os.getenv('DEBUG', 'false').lower() == 'true'
+    
+    print(f"Starting Fake News Detection API server on port {port}...")
+    # Start the Flask server
+    app.run(host='0.0.0.0', port=port, debug=debug)
+
+
+if __name__ == "__main__":
+    main()

misinformationui/.gitignore

@@ -0,0 +1,45 @@
+# Miscellaneous
+*.class
+*.log
+*.pyc
+*.swp
+.DS_Store
+.atom/
+.build/
+.buildlog/
+.history
+.svn/
+.swiftpm/
+migrate_working_dir/
+
+# IntelliJ related
+*.iml
+*.ipr
+*.iws
+.idea/
+
+# The .vscode folder contains launch configuration and tasks you configure in
+# VS Code which you may wish to be included in version control, so this line
+# is commented out by default.
+#.vscode/
+
+# Flutter/Dart/Pub related
+**/doc/api/
+**/ios/Flutter/.last_build_id
+.dart_tool/
+.flutter-plugins
+.flutter-plugins-dependencies
+.pub-cache/
+.pub/
+/build/
+
+# Symbolication related
+app.*.symbols
+
+# Obfuscation related
+app.*.map.json
+
+# Android Studio will place build artifacts here
+/android/app/debug
+/android/app/profile
+/android/app/release

misinformationui/.metadata

@@ -0,0 +1,45 @@
+# This file tracks properties of this Flutter project.
+# Used by Flutter tool to assess capabilities and perform upgrades etc.
+#
+# This file should be version controlled and should not be manually edited.
+
+version:
+  revision: "fcf2c11572af6f390246c056bc905eca609533a0"
+  channel: "stable"
+
+project_type: app
+
+# Tracks metadata for the flutter migrate command
+migration:
+  platforms:
+    - platform: root
+      create_revision: fcf2c11572af6f390246c056bc905eca609533a0
+      base_revision: fcf2c11572af6f390246c056bc905eca609533a0
+    - platform: android
+      create_revision: fcf2c11572af6f390246c056bc905eca609533a0
+      base_revision: fcf2c11572af6f390246c056bc905eca609533a0
+    - platform: ios
+      create_revision: fcf2c11572af6f390246c056bc905eca609533a0
+      base_revision: fcf2c11572af6f390246c056bc905eca609533a0
+    - platform: linux
+      create_revision: fcf2c11572af6f390246c056bc905eca609533a0
+      base_revision: fcf2c11572af6f390246c056bc905eca609533a0
+    - platform: macos
+      create_revision: fcf2c11572af6f390246c056bc905eca609533a0
+      base_revision: fcf2c11572af6f390246c056bc905eca609533a0
+    - platform: web
+      create_revision: fcf2c11572af6f390246c056bc905eca609533a0
+      base_revision: fcf2c11572af6f390246c056bc905eca609533a0
+    - platform: windows
+      create_revision: fcf2c11572af6f390246c056bc905eca609533a0
+      base_revision: fcf2c11572af6f390246c056bc905eca609533a0
+
+  # User provided section
+
+  # List of Local paths (relative to this file) that should be
+  # ignored by the migrate tool.
+  #
+  # Files that are not part of the templates will be ignored by default.
+  unmanaged_files:
+    - 'lib/main.dart'
+    - 'ios/Runner.xcodeproj/project.pbxproj'

misinformationui/README.md

@@ -0,0 +1,16 @@
+# misinformationui
+
+A new Flutter project.
+
+## Getting Started
+
+This project is a starting point for a Flutter application.
+
+A few resources to get you started if this is your first Flutter project:
+
+- [Lab: Write your first Flutter app](https://docs.flutter.dev/get-started/codelab)
+- [Cookbook: Useful Flutter samples](https://docs.flutter.dev/cookbook)
+
+For help getting started with Flutter development, view the
+[online documentation](https://docs.flutter.dev/), which offers tutorials,
+samples, guidance on mobile development, and a full API reference.

misinformationui/analysis_options.yaml

@@ -0,0 +1,28 @@
+# This file configures the analyzer, which statically analyzes Dart code to
+# check for errors, warnings, and lints.
+#
+# The issues identified by the analyzer are surfaced in the UI of Dart-enabled
+# IDEs (https://dart.dev/tools#ides-and-editors). The analyzer can also be
+# invoked from the command line by running `flutter analyze`.
+
+# The following line activates a set of recommended lints for Flutter apps,
+# packages, and plugins designed to encourage good coding practices.
+include: package:flutter_lints/flutter.yaml
+
+linter:
+  # The lint rules applied to this project can be customized in the
+  # section below to disable rules from the `package:flutter_lints/flutter.yaml`
+  # included above or to enable additional rules. A list of all available lints
+  # and their documentation is published at https://dart.dev/lints.
+  #
+  # Instead of disabling a lint rule for the entire project in the
+  # section below, it can also be suppressed for a single line of code
+  # or a specific dart file by using the `// ignore: name_of_lint` and
+  # `// ignore_for_file: name_of_lint` syntax on the line or in the file
+  # producing the lint.
+  rules:
+    # avoid_print: false  # Uncomment to disable the `avoid_print` rule
+    # prefer_single_quotes: true  # Uncomment to enable the `prefer_single_quotes` rule
+
+# Additional information about this file can be found at
+# https://dart.dev/guides/language/analysis-options

misinformationui/android/.gitignore

@@ -0,0 +1,14 @@
+gradle-wrapper.jar
+/.gradle
+/captures/
+/gradlew
+/gradlew.bat
+/local.properties
+GeneratedPluginRegistrant.java
+.cxx/
+
+# Remember to never publicly share your keystore.
+# See https://flutter.dev/to/reference-keystore
+key.properties
+**/*.keystore
+**/*.jks

misinformationui/android/app/build.gradle.kts

@@ -0,0 +1,44 @@
+plugins {
+    id("com.android.application")
+    id("kotlin-android")
+    // The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins.
+    id("dev.flutter.flutter-gradle-plugin")
+}
+
+android {
+    namespace = "com.example.misinformationui"
+    compileSdk = flutter.compileSdkVersion
+    ndkVersion = flutter.ndkVersion
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_11.toString()
+    }
+
+    defaultConfig {
+        // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html).
+        applicationId = "com.example.misinformationui"
+        // You can update the following values to match your application needs.
+        // For more information, see: https://flutter.dev/to/review-gradle-config.
+        minSdk = flutter.minSdkVersion
+        targetSdk = flutter.targetSdkVersion
+        versionCode = flutter.versionCode
+        versionName = flutter.versionName
+    }
+
+    buildTypes {
+        release {
+            // TODO: Add your own signing config for the release build.
+            // Signing with the debug keys for now, so `flutter run --release` works.
+            signingConfig = signingConfigs.getByName("debug")
+        }
+    }
+}
+
+flutter {
+    source = "../.."
+}

misinformationui/android/app/src/debug/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- The INTERNET permission is required for development. Specifically,
+         the Flutter tool needs it to communicate with the running application
+         to allow setting breakpoints, to provide hot reload, etc.
+    -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+</manifest>

misinformationui/android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,45 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application
+        android:label="misinformationui"
+        android:name="${applicationName}"
+        android:icon="@mipmap/ic_launcher">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:launchMode="singleTop"
+            android:taskAffinity=""
+            android:theme="@style/LaunchTheme"
+            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
+            android:hardwareAccelerated="true"
+            android:windowSoftInputMode="adjustResize">
+            <!-- Specifies an Android theme to apply to this Activity as soon as
+                 the Android process has started. This theme is visible to the user
+                 while the Flutter UI initializes. After that, this theme continues
+                 to determine the Window background behind the Flutter UI. -->
+            <meta-data
+              android:name="io.flutter.embedding.android.NormalTheme"
+              android:resource="@style/NormalTheme"
+              />
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+        </activity>
+        <!-- Don't delete the meta-data below.
+             This is used by the Flutter tool to generate GeneratedPluginRegistrant.java -->
+        <meta-data
+            android:name="flutterEmbedding"
+            android:value="2" />
+    </application>
+    <!-- Required to query activities that can process text, see:
+         https://developer.android.com/training/package-visibility and
+         https://developer.android.com/reference/android/content/Intent#ACTION_PROCESS_TEXT.
+
+         In particular, this is used by the Flutter engine in io.flutter.plugin.text.ProcessTextPlugin. -->
+    <queries>
+        <intent>
+            <action android:name="android.intent.action.PROCESS_TEXT"/>
+            <data android:mimeType="text/plain"/>
+        </intent>
+    </queries>
+</manifest>

misinformationui/android/app/src/main/kotlin/com/example/misinformationui/MainActivity.kt

@@ -0,0 +1,5 @@
+package com.example.misinformationui
+
+import io.flutter.embedding.android.FlutterActivity
+
+class MainActivity : FlutterActivity()

misinformationui/android/app/src/main/res/drawable-v21/launch_background.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Modify this file to customize your launch splash screen -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="?android:colorBackground" />
+
+    <!-- You can insert your own image assets here -->
+    <!-- <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@mipmap/launch_image" />
+    </item> -->
+</layer-list>

misinformationui/android/app/src/main/res/drawable/launch_background.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Modify this file to customize your launch splash screen -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="@android:color/white" />
+
+    <!-- You can insert your own image assets here -->
+    <!-- <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@mipmap/launch_image" />
+    </item> -->
+</layer-list>

misinformationui/android/app/src/main/res/values-night/styles.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode setting is on -->
+    <style name="LaunchTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <!-- Show a splash screen on the activity. Automatically removed when
+             the Flutter engine draws its first frame -->
+        <item name="android:windowBackground">@drawable/launch_background</item>
+    </style>
+    <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+    <style name="NormalTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <item name="android:windowBackground">?android:colorBackground</item>
+    </style>
+</resources>

misinformationui/android/app/src/main/res/values/styles.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode setting is off -->
+    <style name="LaunchTheme" parent="@android:style/Theme.Light.NoTitleBar">
+        <!-- Show a splash screen on the activity. Automatically removed when
+             the Flutter engine draws its first frame -->
+        <item name="android:windowBackground">@drawable/launch_background</item>
+    </style>
+    <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+    <style name="NormalTheme" parent="@android:style/Theme.Light.NoTitleBar">
+        <item name="android:windowBackground">?android:colorBackground</item>
+    </style>
+</resources>

misinformationui/android/app/src/profile/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- The INTERNET permission is required for development. Specifically,
+         the Flutter tool needs it to communicate with the running application
+         to allow setting breakpoints, to provide hot reload, etc.
+    -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+</manifest>

misinformationui/android/build.gradle.kts

@@ -0,0 +1,21 @@
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+val newBuildDir: Directory = rootProject.layout.buildDirectory.dir("../../build").get()
+rootProject.layout.buildDirectory.value(newBuildDir)
+
+subprojects {
+    val newSubprojectBuildDir: Directory = newBuildDir.dir(project.name)
+    project.layout.buildDirectory.value(newSubprojectBuildDir)
+}
+subprojects {
+    project.evaluationDependsOn(":app")
+}
+
+tasks.register<Delete>("clean") {
+    delete(rootProject.layout.buildDirectory)
+}

misinformationui/android/gradle.properties

@@ -0,0 +1,3 @@
+org.gradle.jvmargs=-Xmx8G -XX:MaxMetaspaceSize=4G -XX:ReservedCodeCacheSize=512m -XX:+HeapDumpOnOutOfMemoryError
+android.useAndroidX=true
+android.enableJetifier=true

misinformationui/android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-all.zip

misinformationui/android/settings.gradle.kts

@@ -0,0 +1,25 @@
+pluginManagement {
+    val flutterSdkPath = run {
+        val properties = java.util.Properties()
+        file("local.properties").inputStream().use { properties.load(it) }
+        val flutterSdkPath = properties.getProperty("flutter.sdk")
+        require(flutterSdkPath != null) { "flutter.sdk not set in local.properties" }
+        flutterSdkPath
+    }
+
+    includeBuild("$flutterSdkPath/packages/flutter_tools/gradle")
+
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+plugins {
+    id("dev.flutter.flutter-plugin-loader") version "1.0.0"
+    id("com.android.application") version "8.7.3" apply false
+    id("org.jetbrains.kotlin.android") version "2.1.0" apply false
+}
+
+include(":app")

misinformationui/ios/.gitignore

@@ -0,0 +1,34 @@
+**/dgph
+*.mode1v3
+*.mode2v3
+*.moved-aside
+*.pbxuser
+*.perspectivev3
+**/*sync/
+.sconsign.dblite
+.tags*
+**/.vagrant/
+**/DerivedData/
+Icon?
+**/Pods/
+**/.symlinks/
+profile
+xcuserdata
+**/.generated/
+Flutter/App.framework
+Flutter/Flutter.framework
+Flutter/Flutter.podspec
+Flutter/Generated.xcconfig
+Flutter/ephemeral/
+Flutter/app.flx
+Flutter/app.zip
+Flutter/flutter_assets/
+Flutter/flutter_export_environment.sh
+ServiceDefinitions.json
+Runner/GeneratedPluginRegistrant.*
+
+# Exceptions to above rules.
+!default.mode1v3
+!default.mode2v3
+!default.pbxuser
+!default.perspectivev3

misinformationui/ios/Flutter/AppFrameworkInfo.plist

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>en</string>
+  <key>CFBundleExecutable</key>
+  <string>App</string>
+  <key>CFBundleIdentifier</key>
+  <string>io.flutter.flutter.app</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>App</string>
+  <key>CFBundlePackageType</key>
+  <string>FMWK</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0</string>
+  <key>CFBundleSignature</key>
+  <string>????</string>
+  <key>CFBundleVersion</key>
+  <string>1.0</string>
+  <key>MinimumOSVersion</key>
+  <string>12.0</string>
+</dict>
+</plist>

misinformationui/ios/Flutter/Debug.xcconfig

@@ -0,0 +1 @@
+#include "Generated.xcconfig"

misinformationui/ios/Flutter/Release.xcconfig

@@ -0,0 +1 @@
+#include "Generated.xcconfig"

misinformationui/ios/Runner.xcodeproj/project.pbxproj

@@ -0,0 +1,616 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 54;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */ = {isa = PBXBuildFile; fileRef = 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */; };
+		331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C807B294A618700263BE5 /* RunnerTests.swift */; };
+		3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */ = {isa = PBXBuildFile; fileRef = 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */; };
+		74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 74858FAE1ED2DC5600515810 /* AppDelegate.swift */; };
+		97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; };
+		97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; };
+		97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		331C8085294A63A400263BE5 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 97C146E61CF9000F007C117D /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 97C146ED1CF9000F007C117D;
+			remoteInfo = Runner;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		9705A1C41CF9048500538489 /* Embed Frameworks */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "";
+			dstSubfolderSpec = 10;
+			files = (
+			);
+			name = "Embed Frameworks";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GeneratedPluginRegistrant.h; sourceTree = "<group>"; };
+		1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GeneratedPluginRegistrant.m; sourceTree = "<group>"; };
+		331C807B294A618700263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = "<group>"; };
+		331C8081294A63A400263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+		3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = AppFrameworkInfo.plist; path = Flutter/AppFrameworkInfo.plist; sourceTree = "<group>"; };
+		74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Runner-Bridging-Header.h"; sourceTree = "<group>"; };
+		74858FAE1ED2DC5600515810 /* AppDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
+		7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Release.xcconfig; path = Flutter/Release.xcconfig; sourceTree = "<group>"; };
+		9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Debug.xcconfig; path = Flutter/Debug.xcconfig; sourceTree = "<group>"; };
+		9740EEB31CF90195004384FC /* Generated.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Generated.xcconfig; path = Flutter/Generated.xcconfig; sourceTree = "<group>"; };
+		97C146EE1CF9000F007C117D /* Runner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Runner.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		97C146FB1CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
+		97C146FD1CF9000F007C117D /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		97C147001CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
+		97C147021CF9000F007C117D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		97C146EB1CF9000F007C117D /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		331C8082294A63A400263BE5 /* RunnerTests */ = {
+			isa = PBXGroup;
+			children = (
+				331C807B294A618700263BE5 /* RunnerTests.swift */,
+			);
+			path = RunnerTests;
+			sourceTree = "<group>";
+		};
+		9740EEB11CF90186004384FC /* Flutter */ = {
+			isa = PBXGroup;
+			children = (
+				3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */,
+				9740EEB21CF90195004384FC /* Debug.xcconfig */,
+				7AFA3C8E1D35360C0083082E /* Release.xcconfig */,
+				9740EEB31CF90195004384FC /* Generated.xcconfig */,
+			);
+			name = Flutter;
+			sourceTree = "<group>";
+		};
+		97C146E51CF9000F007C117D = {
+			isa = PBXGroup;
+			children = (
+				9740EEB11CF90186004384FC /* Flutter */,
+				97C146F01CF9000F007C117D /* Runner */,
+				97C146EF1CF9000F007C117D /* Products */,
+				331C8082294A63A400263BE5 /* RunnerTests */,
+			);
+			sourceTree = "<group>";
+		};
+		97C146EF1CF9000F007C117D /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				97C146EE1CF9000F007C117D /* Runner.app */,
+				331C8081294A63A400263BE5 /* RunnerTests.xctest */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		97C146F01CF9000F007C117D /* Runner */ = {
+			isa = PBXGroup;
+			children = (
+				97C146FA1CF9000F007C117D /* Main.storyboard */,
+				97C146FD1CF9000F007C117D /* Assets.xcassets */,
+				97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */,
+				97C147021CF9000F007C117D /* Info.plist */,
+				1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */,
+				1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */,
+				74858FAE1ED2DC5600515810 /* AppDelegate.swift */,
+				74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */,
+			);
+			path = Runner;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		331C8080294A63A400263BE5 /* RunnerTests */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */;
+			buildPhases = (
+				331C807D294A63A400263BE5 /* Sources */,
+				331C807F294A63A400263BE5 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				331C8086294A63A400263BE5 /* PBXTargetDependency */,
+			);
+			name = RunnerTests;
+			productName = RunnerTests;
+			productReference = 331C8081294A63A400263BE5 /* RunnerTests.xctest */;
+			productType = "com.apple.product-type.bundle.unit-test";
+		};
+		97C146ED1CF9000F007C117D /* Runner */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */;
+			buildPhases = (
+				9740EEB61CF901F6004384FC /* Run Script */,
+				97C146EA1CF9000F007C117D /* Sources */,
+				97C146EB1CF9000F007C117D /* Frameworks */,
+				97C146EC1CF9000F007C117D /* Resources */,
+				9705A1C41CF9048500538489 /* Embed Frameworks */,
+				3B06AD1E1E4923F5004D2608 /* Thin Binary */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = Runner;
+			productName = Runner;
+			productReference = 97C146EE1CF9000F007C117D /* Runner.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		97C146E61CF9000F007C117D /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				BuildIndependentTargetsInParallel = YES;
+				LastUpgradeCheck = 1510;
+				ORGANIZATIONNAME = "";
+				TargetAttributes = {
+					331C8080294A63A400263BE5 = {
+						CreatedOnToolsVersion = 14.0;
+						TestTargetID = 97C146ED1CF9000F007C117D;
+					};
+					97C146ED1CF9000F007C117D = {
+						CreatedOnToolsVersion = 7.3.1;
+						LastSwiftMigration = 1100;
+					};
+				};
+			};
+			buildConfigurationList = 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */;
+			compatibilityVersion = "Xcode 9.3";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 97C146E51CF9000F007C117D;
+			productRefGroup = 97C146EF1CF9000F007C117D /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				97C146ED1CF9000F007C117D /* Runner */,
+				331C8080294A63A400263BE5 /* RunnerTests */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		331C807F294A63A400263BE5 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		97C146EC1CF9000F007C117D /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */,
+				3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */,
+				97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */,
+				97C146FC1CF9000F007C117D /* Main.storyboard in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		3B06AD1E1E4923F5004D2608 /* Thin Binary */ = {
+			isa = PBXShellScriptBuildPhase;
+			alwaysOutOfDate = 1;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+				"${TARGET_BUILD_DIR}/${INFOPLIST_PATH}",
+			);
+			name = "Thin Binary";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" embed_and_thin";
+		};
+		9740EEB61CF901F6004384FC /* Run Script */ = {
+			isa = PBXShellScriptBuildPhase;
+			alwaysOutOfDate = 1;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			name = "Run Script";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build";
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		331C807D294A63A400263BE5 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		97C146EA1CF9000F007C117D /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */,
+				1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		331C8086294A63A400263BE5 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 97C146ED1CF9000F007C117D /* Runner */;
+			targetProxy = 331C8085294A63A400263BE5 /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin PBXVariantGroup section */
+		97C146FA1CF9000F007C117D /* Main.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				97C146FB1CF9000F007C117D /* Base */,
+			);
+			name = Main.storyboard;
+			sourceTree = "<group>";
+		};
+		97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				97C147001CF9000F007C117D /* Base */,
+			);
+			name = LaunchScreen.storyboard;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		249021D3217E4FDB00AE95B9 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 12.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SUPPORTED_PLATFORMS = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Profile;
+		};
+		249021D4217E4FDB00AE95B9 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				ENABLE_BITCODE = NO;
+				INFOPLIST_FILE = Runner/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.misinformationui;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
+				SWIFT_VERSION = 5.0;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Profile;
+		};
+		331C8088294A63A400263BE5 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				GENERATE_INFOPLIST_FILE = YES;
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.misinformationui.RunnerTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner";
+			};
+			name = Debug;
+		};
+		331C8089294A63A400263BE5 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				GENERATE_INFOPLIST_FILE = YES;
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.misinformationui.RunnerTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 5.0;
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner";
+			};
+			name = Release;
+		};
+		331C808A294A63A400263BE5 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				GENERATE_INFOPLIST_FILE = YES;
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.misinformationui.RunnerTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 5.0;
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner";
+			};
+			name = Profile;
+		};
+		97C147031CF9000F007C117D /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 12.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		97C147041CF9000F007C117D /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 12.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SUPPORTED_PLATFORMS = iphoneos;
+				SWIFT_COMPILATION_MODE = wholemodule;
+				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		97C147061CF9000F007C117D /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				ENABLE_BITCODE = NO;
+				INFOPLIST_FILE = Runner/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.misinformationui;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Debug;
+		};
+		97C147071CF9000F007C117D /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				ENABLE_BITCODE = NO;
+				INFOPLIST_FILE = Runner/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.misinformationui;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
+				SWIFT_VERSION = 5.0;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				331C8088294A63A400263BE5 /* Debug */,
+				331C8089294A63A400263BE5 /* Release */,
+				331C808A294A63A400263BE5 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				97C147031CF9000F007C117D /* Debug */,
+				97C147041CF9000F007C117D /* Release */,
+				249021D3217E4FDB00AE95B9 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				97C147061CF9000F007C117D /* Debug */,
+				97C147071CF9000F007C117D /* Release */,
+				249021D4217E4FDB00AE95B9 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 97C146E61CF9000F007C117D /* Project object */;
+}

misinformationui/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>

misinformationui/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

misinformationui/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>PreviewsEnabled</key>
+	<false/>
+</dict>
+</plist>

misinformationui/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme

@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1510"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+               BuildableName = "Runner.app"
+               BlueprintName = "Runner"
+               ReferencedContainer = "container:Runner.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      customLLDBInitFile = "$(SRCROOT)/Flutter/ephemeral/flutter_lldbinit"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+            BuildableName = "Runner.app"
+            BlueprintName = "Runner"
+            ReferencedContainer = "container:Runner.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <Testables>
+         <TestableReference
+            skipped = "NO"
+            parallelizable = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "331C8080294A63A400263BE5"
+               BuildableName = "RunnerTests.xctest"
+               BlueprintName = "RunnerTests"
+               ReferencedContainer = "container:Runner.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      customLLDBInitFile = "$(SRCROOT)/Flutter/ephemeral/flutter_lldbinit"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      enableGPUValidationMode = "1"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+            BuildableName = "Runner.app"
+            BlueprintName = "Runner"
+            ReferencedContainer = "container:Runner.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Profile"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+            BuildableName = "Runner.app"
+            BlueprintName = "Runner"
+            ReferencedContainer = "container:Runner.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

misinformationui/ios/Runner.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "group:Runner.xcodeproj">
+   </FileRef>
+</Workspace>

misinformationui/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

misinformationui/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>PreviewsEnabled</key>
+	<false/>
+</dict>
+</plist>

misinformationui/ios/Runner/AppDelegate.swift

@@ -0,0 +1,13 @@
+import Flutter
+import UIKit
+
+@main
+@objc class AppDelegate: FlutterAppDelegate {
+  override func application(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
+  ) -> Bool {
+    GeneratedPluginRegistrant.register(with: self)
+    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
+  }
+}

misinformationui/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,122 @@
+{
+  "images" : [
+    {
+      "size" : "20x20",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "20x20",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "3x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "1x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "3x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "3x"
+    },
+    {
+      "size" : "60x60",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "60x60",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "3x"
+    },
+    {
+      "size" : "20x20",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "1x"
+    },
+    {
+      "size" : "20x20",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "1x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "1x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "76x76",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "1x"
+    },
+    {
+      "size" : "76x76",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "83.5x83.5",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "1024x1024",
+      "idiom" : "ios-marketing",
+      "filename" : "[email protected]",
+      "scale" : "1x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}