test

.env

@@ -1,9 +1,10 @@
 FLASK_APP=app.py
 FLASK_ENV=development
-SECRET_KEY=your-secret-key-here
-DATABASE_URL=postgresql://user:password@localhost:5432/facebook_ads
-CELERY_BROKER_URL=redis://localhost:6379/0
-CELERY_RESULT_BACKEND=redis://localhost:6379/0
-OPENAI_API_KEY=your-openai-api-key-here
+FLASK_DEBUG=1
+SECRET_KEY=dev-secret-key-change-in-production
+DATABASE_URL=sqlite:///app.db
+CELERY_BROKER_URL=sqla+sqlite:///celery.db
+CELERY_RESULT_BACKEND=db+sqlite:///celery-results.db
+OPENAI_API_KEY=sk-mock-key-for-development
 INSTANCE_PATH=/tmp/instance
 SELENIUM_HUB_URL=http://selenium-hub:4444/wd/hub

app.py

@@ -2,6 +2,11 @@ from flask import Flask
 from flask_migrate import Migrate
 from app import db, create_app
 from config import get_config
+from dotenv import load_dotenv
+import os
+
+# Load environment variables from .env file
+load_dotenv()
 
 migrate = Migrate()
 
@@ -10,6 +15,6 @@ def create_flask_app():
     migrate.init_app(app, db)
     return app
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     app = create_flask_app()
     app.run(debug=True)

app/__init__.py

@@ -1,7 +1,9 @@
 from flask import Flask
 from flask_sqlalchemy import SQLAlchemy
+from flask_migrate import Migrate
 from flask_login import LoginManager
 from celery import Celery
+from config import Config
 import redis
 import os
 import logging
@@ -18,9 +20,10 @@ logger = logging.getLogger(__name__)
 
 # Initialize extensions
 db = SQLAlchemy()
+migrate = Migrate()
 login = LoginManager()
 login.login_view = 'auth.login'
-celery = Celery(__name__)
+celery = Celery(__name__, broker=Config.CELERY_BROKER_URL)
 cache = None  # Initialize later when app context is available
 
 # Set up user loader for Flask-Login
@@ -29,7 +32,7 @@ def load_user(user_id):
     from .models import User
     return User.query.get(int(user_id))
 
-def create_app(config_class=None):
+def create_app(config_class=Config):
     logger.info("Starting application initialization...")
     
     # Create the Flask app
@@ -37,12 +40,8 @@ def create_app(config_class=None):
     logger.info("Flask app created")
     
     # Load configuration
-    if config_class is None:
-        logger.info("Loading default configuration...")
-        app.config.from_object('config.Config')
-    else:
-        logger.info(f"Loading configuration from {config_class}...")
-        app.config.from_object(config_class)
+    logger.info(f"Loading configuration from {config_class}...")
+    app.config.from_object(config_class)
     
     # Ensure instance path exists
     logger.info(f"Ensuring instance path exists: {app.config['INSTANCE_PATH']}")
@@ -52,6 +51,7 @@ def create_app(config_class=None):
     # Initialize extensions
     logger.info("Initializing SQLAlchemy...")
     db.init_app(app)
+    migrate.init_app(app, db)
     
     logger.info("Initializing LoginManager...")
     login.init_app(app)
@@ -64,12 +64,18 @@ def create_app(config_class=None):
     try:
         logger.info(f"Initializing Redis cache with URL: {app.config['CELERY_BROKER_URL']}")
         global cache
-        cache = redis.Redis.from_url(app.config['CELERY_BROKER_URL'])
-        logger.info("Redis cache initialized successfully")
+        # Only try to connect to Redis if the URL starts with 'redis://'
+        if app.config['CELERY_BROKER_URL'].startswith('redis://'):
+            cache = redis.Redis.from_url(app.config['CELERY_BROKER_URL'])
+            logger.info("Redis cache initialized successfully")
+        else:
+            logger.info("Not using Redis cache as broker URL is not Redis")
+            cache = None
     except Exception as e:
         logger.error(f"Error initializing Redis cache: {e}")
-        # Continue without Redis for now
-        pass
+        # Continue without Redis
+        cache = None
+        logger.info("Continuing without Redis cache")
     
     # Register test blueprint first (this should always work)
     logger.info("Registering test blueprint...")
@@ -124,6 +130,14 @@ def create_app(config_class=None):
     except Exception as e:
         logger.error(f"Error registering auth blueprint: {e}")
     
+    try:
+        logger.info("Importing and registering Facebook Ads blueprint...")
+        from .routes.facebook_ads import facebook_ads_bp
+        app.register_blueprint(facebook_ads_bp)
+        logger.info("Facebook Ads blueprint registered successfully")
+    except Exception as e:
+        logger.error(f"Error registering Facebook Ads blueprint: {e}")
+    
     # Add a simple route directly to the app
     @app.route('/')
     def index():

app/models/facebook_ad.py

@@ -0,0 +1,113 @@
+from app import db
+from datetime import datetime
+import uuid
+import json
+
+class FacebookAd(db.Model):
+    """Model for storing Facebook Ads data."""
+    id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    
+    # Facebook-specific fields
+    ad_id = db.Column(db.String(255), nullable=True, index=True)
+    advertiser = db.Column(db.String(255), nullable=True, index=True)
+    advertiser_id = db.Column(db.String(255), nullable=True, index=True)
+    
+    # Content fields
+    content = db.Column(db.Text, nullable=True)
+    images = db.Column(db.JSON, nullable=True)  # URLs to images
+    links = db.Column(db.JSON, nullable=True)   # URLs in the ad
+    
+    # Search metadata
+    search_query = db.Column(db.String(255), nullable=True, index=True)
+    position = db.Column(db.Integer, nullable=True)
+    
+    # Analysis results
+    sentiment = db.Column(db.JSON, nullable=True)
+    topics = db.Column(db.JSON, nullable=True)
+    entities = db.Column(db.JSON, nullable=True)
+    
+    # Raw data for future processing
+    raw_data = db.Column(db.JSON, nullable=True)
+    raw_text = db.Column(db.Text, nullable=True)
+    
+    # Timestamps
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    # User association
+    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
+    
+    def __repr__(self):
+        return f'<FacebookAd {self.id} - {self.advertiser}>'
+    
+    @classmethod
+    def from_scraper_data(cls, ad_data, user_id=None):
+        """Create a FacebookAd instance from scraped data."""
+        # Extract fields from the scraped data
+        ad = cls(
+            ad_id=ad_data.get('ad_id'),
+            advertiser=ad_data.get('advertiser'),
+            advertiser_id=ad_data.get('advertiser_id'),
+            content=ad_data.get('content'),
+            raw_text=ad_data.get('raw_text'),
+            search_query=ad_data.get('search_query'),
+            position=ad_data.get('position'),
+            user_id=user_id
+        )
+        
+        # Handle JSON fields
+        if 'images' in ad_data and ad_data['images']:
+            ad.images = ad_data['images']
+            
+        if 'links' in ad_data and ad_data['links']:
+            ad.links = ad_data['links']
+        
+        # Store the full raw data for future reference
+        ad.raw_data = {k: v for k, v in ad_data.items() if k not in ['images', 'links']}
+        
+        return ad
+    
+    def get_image_urls(self):
+        """Get list of image URLs from the ad."""
+        if not self.images:
+            return []
+        
+        if isinstance(self.images, str):
+            try:
+                return json.loads(self.images)
+            except:
+                return []
+        
+        return self.images
+    
+    def get_links(self):
+        """Get list of links from the ad."""
+        if not self.links:
+            return []
+        
+        if isinstance(self.links, str):
+            try:
+                return json.loads(self.links)
+            except:
+                return []
+        
+        return self.links
+    
+    def to_dict(self):
+        """Convert the ad to a dictionary for API responses."""
+        return {
+            'id': self.id,
+            'ad_id': self.ad_id,
+            'advertiser': self.advertiser,
+            'advertiser_id': self.advertiser_id,
+            'content': self.content,
+            'images': self.get_image_urls(),
+            'links': self.get_links(),
+            'search_query': self.search_query,
+            'position': self.position,
+            'sentiment': self.sentiment,
+            'topics': self.topics,
+            'entities': self.entities,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None
+        } 

app/routes/facebook_ads.py

@@ -0,0 +1,310 @@
+from flask import Blueprint, render_template, request, jsonify, current_app, flash, redirect, url_for
+from flask_login import login_required, current_user
+from app.services.facebook_scraper import FacebookScraper
+from app.models.facebook_ad import FacebookAd
+from app.services.ai_processor import AIPipeline
+from app import db, celery
+import logging
+import json
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+facebook_ads_bp = Blueprint('facebook_ads', __name__, url_prefix='/facebook-ads')
+
+@facebook_ads_bp.route('/', methods=['GET'])
+@login_required
+def index():
+    """Facebook Ads dashboard page."""
+    return render_template('facebook_ads/index.html')
+
+@facebook_ads_bp.route('/search', methods=['GET', 'POST'])
+@login_required
+def search():
+    """Search for Facebook ads."""
+    if request.method == 'POST':
+        search_query = request.form.get('search_query', '')
+        num_scrolls = int(request.form.get('num_scrolls', 5))
+        country_code = request.form.get('country_code', 'ALL')
+        
+        if not search_query:
+            flash('Please enter a search query', 'warning')
+            return render_template('facebook_ads/search.html')
+        
+        # Start the scraping task
+        task = scrape_facebook_ads.delay(search_query, num_scrolls, country_code, current_user.id)
+        
+        flash(f'Started scraping Facebook ads for "{search_query}". This may take a few minutes.', 'info')
+        return render_template('facebook_ads/search.html', task_id=task.id)
+    
+    return render_template('facebook_ads/search.html')
+
+@facebook_ads_bp.route('/page-search', methods=['GET', 'POST'])
+@login_required
+def page_search():
+    """Search for ads from a specific Facebook page."""
+    if request.method == 'POST':
+        page_name = request.form.get('page_name', '')
+        num_scrolls = int(request.form.get('num_scrolls', 5))
+        
+        if not page_name:
+            flash('Please enter a page name', 'warning')
+            return render_template('facebook_ads/page_search.html')
+        
+        # Start the scraping task
+        task = scrape_facebook_page_ads.delay(page_name, num_scrolls, current_user.id)
+        
+        flash(f'Started scraping Facebook ads for page "{page_name}". This may take a few minutes.', 'info')
+        return render_template('facebook_ads/page_search.html', task_id=task.id)
+    
+    return render_template('facebook_ads/page_search.html')
+
+@facebook_ads_bp.route('/results', methods=['GET'])
+@login_required
+def results():
+    """View Facebook ads results."""
+    ad_type = request.args.get('type', 'all')
+    query = request.args.get('query', '')
+    advertiser = request.args.get('advertiser', '')
+    
+    # Build query
+    ads_query = FacebookAd.query
+    
+    if query:
+        ads_query = ads_query.filter(FacebookAd.search_query.ilike(f'%{query}%'))
+    
+    if advertiser:
+        ads_query = ads_query.filter(FacebookAd.advertiser.ilike(f'%{advertiser}%'))
+    
+    # Get results
+    ads = ads_query.order_by(FacebookAd.created_at.desc()).limit(100).all()
+    
+    return render_template('facebook_ads/results.html', ads=ads, query=query, advertiser=advertiser)
+
+@facebook_ads_bp.route('/ad/<ad_id>', methods=['GET'])
+@login_required
+def view_ad(ad_id):
+    """View details of a specific Facebook ad."""
+    ad = FacebookAd.query.get_or_404(ad_id)
+    return render_template('facebook_ads/ad_detail.html', ad=ad)
+
+@facebook_ads_bp.route('/advertisers', methods=['GET'])
+@login_required
+def advertisers():
+    """View list of advertisers."""
+    # Get unique advertisers and count their ads
+    advertisers_data = db.session.query(
+        FacebookAd.advertiser, 
+        db.func.count(FacebookAd.id).label('ad_count')
+    ).group_by(FacebookAd.advertiser).order_by(db.func.count(FacebookAd.id).desc()).limit(100).all()
+    
+    return render_template('facebook_ads/advertisers.html', advertisers=advertisers_data)
+
+@facebook_ads_bp.route('/advertiser/<advertiser_name>', methods=['GET'])
+@login_required
+def advertiser_detail(advertiser_name):
+    """View details and ads for a specific advertiser."""
+    ads = FacebookAd.query.filter(FacebookAd.advertiser == advertiser_name).order_by(FacebookAd.created_at.desc()).all()
+    return render_template('facebook_ads/advertiser_detail.html', advertiser=advertiser_name, ads=ads)
+
+@facebook_ads_bp.route('/analyze/<ad_id>', methods=['GET'])
+@login_required
+def analyze_ad(ad_id):
+    """Analyze a specific Facebook ad."""
+    ad = FacebookAd.query.get_or_404(ad_id)
+    
+    # Start the analysis task if not already analyzed
+    if not ad.sentiment or not ad.topics:
+        task = analyze_facebook_ad.delay(ad_id)
+        flash('Started analyzing the ad. Refresh in a few moments to see results.', 'info')
+    
+    return render_template('facebook_ads/ad_analysis.html', ad=ad)
+
+@facebook_ads_bp.route('/api/ads', methods=['GET'])
+@login_required
+def api_get_ads():
+    """API endpoint to get Facebook Ads data."""
+    query = request.args.get('query', '')
+    advertiser = request.args.get('advertiser', '')
+    limit = int(request.args.get('limit', 50))
+    
+    # Build query
+    ads_query = FacebookAd.query
+    
+    if query:
+        ads_query = ads_query.filter(
+            (FacebookAd.content.ilike(f'%{query}%')) | 
+            (FacebookAd.search_query.ilike(f'%{query}%'))
+        )
+    
+    if advertiser:
+        ads_query = ads_query.filter(FacebookAd.advertiser.ilike(f'%{advertiser}%'))
+    
+    # Get results
+    ads = ads_query.order_by(FacebookAd.created_at.desc()).limit(limit).all()
+    
+    # Convert to JSON
+    result = [ad.to_dict() for ad in ads]
+    
+    return jsonify(result)
+
+@facebook_ads_bp.route('/api/advertisers', methods=['GET'])
+@login_required
+def api_get_advertisers():
+    """API endpoint to get advertisers data."""
+    limit = int(request.args.get('limit', 50))
+    
+    # Get unique advertisers and count their ads
+    advertisers_data = db.session.query(
+        FacebookAd.advertiser, 
+        db.func.count(FacebookAd.id).label('ad_count')
+    ).group_by(FacebookAd.advertiser).order_by(db.func.count(FacebookAd.id).desc()).limit(limit).all()
+    
+    # Convert to JSON
+    result = [{"name": adv[0], "ad_count": adv[1]} for adv in advertisers_data if adv[0]]
+    
+    return jsonify(result)
+
+@celery.task
+def scrape_facebook_ads(search_query, num_scrolls, country_code, user_id):
+    """Celery task to scrape Facebook ads."""
+    try:
+        logger.info(f"Starting Facebook ads scraping for query: {search_query}")
+        
+        # Initialize scraper
+        scraper = FacebookScraper()
+        
+        # Scrape ads
+        ads_data = scraper.scrape_ads(search_query, num_scrolls, country_code)
+        
+        logger.info(f"Scraped {len(ads_data)} Facebook ads")
+        
+        # Process and store ads
+        ai_pipeline = AIPipeline()
+        
+        for ad_data in ads_data:
+            # Create FacebookAd instance
+            ad = FacebookAd.from_scraper_data(ad_data, user_id)
+            
+            # Process with AI if there's content
+            if ad.content:
+                try:
+                    # Create a simple object with content for AI processing
+                    ad_content = type('obj', (object,), {
+                        'content': ad.content
+                    })
+                    
+                    # Process with AI
+                    ai_results = ai_pipeline.process_ad(ad_content)
+                    ad.sentiment = ai_results.get('sentiment')
+                except Exception as e:
+                    logger.error(f"Error processing ad with AI: {e}")
+            
+            # Save to database
+            db.session.add(ad)
+        
+        db.session.commit()
+        logger.info(f"Saved {len(ads_data)} Facebook ads to database")
+        
+        return {'status': 'success', 'count': len(ads_data)}
+    
+    except Exception as e:
+        logger.error(f"Error in Facebook ads scraping task: {e}")
+        db.session.rollback()
+        return {'status': 'error', 'message': str(e)}
+
+@celery.task
+def scrape_facebook_page_ads(page_name, num_scrolls, user_id):
+    """Celery task to scrape ads from a specific Facebook page."""
+    try:
+        logger.info(f"Starting Facebook page ads scraping for page: {page_name}")
+        
+        # Initialize scraper
+        scraper = FacebookScraper()
+        
+        # Scrape ads
+        ads_data = scraper.scrape_ads_by_page(page_name, num_scrolls)
+        
+        logger.info(f"Scraped {len(ads_data)} Facebook ads from page {page_name}")
+        
+        # Process and store ads
+        ai_pipeline = AIPipeline()
+        
+        for ad_data in ads_data:
+            # Create FacebookAd instance
+            ad = FacebookAd.from_scraper_data(ad_data, user_id)
+            
+            # Process with AI if there's content
+            if ad.content:
+                try:
+                    # Create a simple object with content for AI processing
+                    ad_content = type('obj', (object,), {
+                        'content': ad.content
+                    })
+                    
+                    # Process with AI
+                    ai_results = ai_pipeline.process_ad(ad_content)
+                    ad.sentiment = ai_results.get('sentiment')
+                except Exception as e:
+                    logger.error(f"Error processing ad with AI: {e}")
+            
+            # Save to database
+            db.session.add(ad)
+        
+        db.session.commit()
+        logger.info(f"Saved {len(ads_data)} Facebook ads to database")
+        
+        return {'status': 'success', 'count': len(ads_data)}
+    
+    except Exception as e:
+        logger.error(f"Error in Facebook page ads scraping task: {e}")
+        db.session.rollback()
+        return {'status': 'error', 'message': str(e)}
+
+@celery.task
+def analyze_facebook_ad(ad_id):
+    """Celery task to analyze a Facebook ad."""
+    try:
+        logger.info(f"Starting analysis for Facebook ad: {ad_id}")
+        
+        # Get the ad
+        ad = FacebookAd.query.get(ad_id)
+        
+        if not ad:
+            logger.error(f"Ad not found: {ad_id}")
+            return {'status': 'error', 'message': 'Ad not found'}
+        
+        # Initialize AI pipeline
+        ai_pipeline = AIPipeline()
+        
+        # Process with AI if there's content
+        if ad.content:
+            try:
+                # Create a simple object with content for AI processing
+                ad_content = type('obj', (object,), {
+                    'content': ad.content
+                })
+                
+                # Process with AI
+                ai_results = ai_pipeline.process_ad(ad_content)
+                
+                # Update ad with results
+                ad.sentiment = ai_results.get('sentiment')
+                ad.topics = ai_results.get('topics')
+                ad.entities = ai_results.get('entities')
+                
+                # Save to database
+                db.session.commit()
+                
+                logger.info(f"Successfully analyzed Facebook ad: {ad_id}")
+                return {'status': 'success', 'ad_id': ad_id}
+            except Exception as e:
+                logger.error(f"Error processing ad with AI: {e}")
+                return {'status': 'error', 'message': str(e)}
+        else:
+            logger.warning(f"No content to analyze for ad: {ad_id}")
+            return {'status': 'warning', 'message': 'No content to analyze'}
+    
+    except Exception as e:
+        logger.error(f"Error in Facebook ad analysis task: {e}")
+        db.session.rollback()
+        return {'status': 'error', 'message': str(e)} 

app/services/ai_processor.py

@@ -1,5 +1,10 @@
 from pathlib import Path
 import logging
+import json
+from transformers import pipeline
+from textblob import TextBlob
+import spacy
+import re
 
 logger = logging.getLogger(__name__)
 
@@ -9,89 +14,124 @@ class ProcessingError(Exception):
 
 class AIPipeline:
     def __init__(self):
-        self.nlp = None  # Initialize as None
-        self.detector = None
+        """Initialize the AI pipeline with necessary models."""
         try:
-            model_dir = Path("app/models")
-            weights_path = model_dir / "yolov4.weights"
-            config_path = model_dir / "yolov4.cfg"
+            # Load spaCy model for NER and topic extraction
+            self.nlp = spacy.load('en_core_web_sm')
             
-            if not (weights_path.exists() and config_path.exists()):
-                logger.warning("YOLOv4 files not found. Please run setup_yolo.py first.")
-            else:
-                # Lazy load OpenCV
-                self._setup_detector(str(weights_path), str(config_path))
-                
+            # Initialize sentiment analyzer
+            self.sentiment = pipeline('sentiment-analysis', model='distilbert-base-uncased-finetuned-sst-2-english')
+            
+            logger.info("AI Pipeline initialized successfully")
         except Exception as e:
             logger.error(f"Error initializing AI Pipeline: {e}")
             raise
 
-    def _setup_detector(self, weights_path, config_path):
-        """Set up the object detector with the given weights and config."""
-        try:
-            import cv2
-            self.detector = cv2.dnn.readNet(weights_path, config_path)
-        except Exception as e:
-            logger.error(f"Error setting up detector: {e}")
-            self.detector = None
-
-    def _ensure_nlp_loaded(self):
-        """Ensure NLP model is loaded before use."""
-        if self.nlp is None:
-            try:
-                logger.info("Loading NLP model...")
-                # Import transformers only when needed
-                from transformers import pipeline
-                self.nlp = pipeline("text-classification", model="roberta-base")
-                logger.info("NLP model loaded successfully")
-            except Exception as e:
-                logger.error(f"Error loading NLP model: {e}")
-                raise
-
-    def process_ad(self, ad):
-        if not ad:
-            raise ValueError("Ad content cannot be empty")
-        
+    def _analyze_sentiment(self, text: str) -> float:
+        """Analyze sentiment of text and return a score between -1 and 1."""
         try:
-            results = {
-                "sentiment": self._analyze_sentiment(ad.content),
-                "ocr": self._extract_ocr(ad.media) if hasattr(ad, 'media') else None,
-                "objects": self._detect_objects(ad.media) if hasattr(ad, 'media') else None
-            }
-            return results
+            # Use transformers for initial sentiment
+            result = self.sentiment(text)[0]
+            
+            # Convert POSITIVE/NEGATIVE to float
+            if result['label'] == 'POSITIVE':
+                score = result['score']
+            else:
+                score = -result['score']
+            
+            # Use TextBlob for additional nuance
+            blob = TextBlob(text)
+            blob_score = blob.sentiment.polarity
+            
+            # Average the scores
+            final_score = (score + blob_score) / 2
+            
+            return final_score
         except Exception as e:
-            logger.error(f"Error processing ad: {str(e)}")
-            raise ProcessingError(f"Failed to process ad: {str(e)}")
+            logger.error(f"Error in sentiment analysis: {e}")
+            return 0.0
 
-    def _analyze_sentiment(self, text):
-        if not text:
-            return None
+    def _extract_topics(self, text: str) -> list:
+        """Extract main topics from text."""
         try:
-            self._ensure_nlp_loaded()  # Load model if needed
-            return self.nlp(text)[0]
+            doc = self.nlp(text)
+            
+            # Extract noun phrases as potential topics
+            noun_phrases = [chunk.text.lower() for chunk in doc.noun_chunks]
+            
+            # Extract named entities that might be topics
+            entities = [ent.text.lower() for ent in doc.ents 
+                      if ent.label_ in ['ORG', 'PRODUCT', 'EVENT', 'WORK_OF_ART']]
+            
+            # Combine and clean topics
+            all_topics = noun_phrases + entities
+            
+            # Clean and filter topics
+            cleaned_topics = []
+            for topic in all_topics:
+                # Remove special characters and extra whitespace
+                topic = re.sub(r'[^\w\s]', '', topic)
+                topic = ' '.join(topic.split())
+                
+                # Filter out short or common words
+                if len(topic) > 3 and topic not in ['the', 'this', 'that', 'these', 'those']:
+                    cleaned_topics.append(topic)
+            
+            # Remove duplicates and limit to top 5
+            unique_topics = list(set(cleaned_topics))
+            return sorted(unique_topics)[:5]
         except Exception as e:
-            logger.error(f"Sentiment analysis error: {e}")
-            return None
+            logger.error(f"Error in topic extraction: {e}")
+            return []
 
-    def _extract_ocr(self, media):
-        if not media or not hasattr(media, 'type') or media.type != "image":
-            return None
+    def _extract_entities(self, text: str) -> list:
+        """Extract named entities from text."""
         try:
-            import pytesseract
-            return pytesseract.image_to_string(media.path)
+            doc = self.nlp(text)
+            
+            entities = []
+            for ent in doc.ents:
+                entity = {
+                    'text': ent.text,
+                    'type': ent.label_,
+                    'description': spacy.explain(ent.label_)
+                }
+                entities.append(entity)
+            
+            return entities
         except Exception as e:
-            logger.error(f"OCR error: {e}")
-            return None
+            logger.error(f"Error in entity extraction: {e}")
+            return []
 
-    def _detect_objects(self, media):
-        if not media or not hasattr(media, 'type') or media.type != "image" or not self.detector:
-            return None
+    def process_ad(self, ad) -> dict:
+        """Process an ad and return analysis results."""
         try:
-            import cv2
-            img = cv2.imread(media.path)
-            blob = cv2.dnn.blobFromImage(img, 1/255, (416, 416), swapRB=True, crop=False)
-            self.detector.setInput(blob)
-            return self.detector.forward()
+            # Ensure we have content to analyze
+            if not hasattr(ad, 'content') or not ad.content:
+                return {
+                    'sentiment': 0.0,
+                    'topics': [],
+                    'entities': []
+                }
+            
+            # Analyze sentiment
+            sentiment = self._analyze_sentiment(ad.content)
+            
+            # Extract topics
+            topics = self._extract_topics(ad.content)
+            
+            # Extract entities
+            entities = self._extract_entities(ad.content)
+            
+            return {
+                'sentiment': sentiment,
+                'topics': topics,
+                'entities': entities
+            }
         except Exception as e:
-            logger.error(f"Object detection error: {e}")
-            return None
+            logger.error(f"Error in ad processing: {e}")
+            return {
+                'sentiment': 0.0,
+                'topics': [],
+                'entities': []
+            }

app/services/facebook_scraper.py

@@ -0,0 +1,417 @@
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import TimeoutException, WebDriverException, NoSuchElementException
+from webdriver_manager.chrome import ChromeDriverManager
+import time
+import json
+import logging
+import re
+from datetime import datetime
+from contextlib import contextmanager
+from typing import List, Dict, Any, Optional
+from bs4 import BeautifulSoup
+from urllib.parse import urlparse, parse_qs
+
+logger = logging.getLogger(__name__)
+
+class FacebookScraper:
+    """
+    Enhanced Facebook Ads Library scraper with improved robustness and features.
+    """
+    
+    def __init__(self, headless: bool = True, timeout: int = 10, use_proxy: bool = False, proxy: str = None):
+        """
+        Initialize the Facebook scraper with configurable options.
+        
+        Args:
+            headless: Whether to run the browser in headless mode
+            timeout: Default timeout for waiting operations in seconds
+            use_proxy: Whether to use a proxy
+            proxy: Proxy server address (e.g., "http://user:pass@ip:port")
+        """
+        self.driver = None
+        self.headless = headless
+        self.timeout = timeout
+        self.use_proxy = use_proxy
+        self.proxy = proxy
+        
+    def _setup_driver(self):
+        """Configure and initialize the Chrome WebDriver with optimal settings."""
+        options = webdriver.ChromeOptions()
+        
+        if self.headless:
+            options.add_argument("--headless")
+            
+        # Add common options for stability
+        options.add_argument("--no-sandbox")
+        options.add_argument("--disable-dev-shm-usage")
+        options.add_argument("--disable-gpu")
+        options.add_argument("--window-size=1920,1080")
+        
+        # Add user agent to appear more like a regular browser
+        options.add_argument("--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36")
+        
+        # Add proxy if specified
+        if self.use_proxy and self.proxy:
+            options.add_argument(f'--proxy-server={self.proxy}')
+            
+        # Disable automation flags to avoid detection
+        options.add_experimental_option("excludeSwitches", ["enable-automation"])
+        options.add_experimental_option('useAutomationExtension', False)
+        
+        return webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
+
+    @contextmanager
+    def _get_driver(self):
+        """Context manager for browser session to ensure proper cleanup."""
+        try:
+            self.driver = self._setup_driver()
+            yield self.driver
+        except Exception as e:
+            logger.error(f"Error initializing WebDriver: {e}")
+            raise
+        finally:
+            if self.driver:
+                self.driver.quit()
+                
+    def _wait_for_element(self, driver, selector: str, by: By = By.CSS_SELECTOR, timeout: int = None) -> Any:
+        """
+        Wait for an element to be present and return it.
+        
+        Args:
+            driver: WebDriver instance
+            selector: Element selector
+            by: Selector type (CSS, XPATH, etc.)
+            timeout: Wait timeout in seconds
+            
+        Returns:
+            The found web element
+        """
+        if timeout is None:
+            timeout = self.timeout
+            
+        wait = WebDriverWait(driver, timeout)
+        return wait.until(EC.presence_of_element_located((by, selector)))
+    
+    def _wait_for_elements(self, driver, selector: str, by: By = By.CSS_SELECTOR, timeout: int = None) -> List[Any]:
+        """
+        Wait for elements to be present and return them.
+        
+        Args:
+            driver: WebDriver instance
+            selector: Elements selector
+            by: Selector type (CSS, XPATH, etc.)
+            timeout: Wait timeout in seconds
+            
+        Returns:
+            List of found web elements
+        """
+        if timeout is None:
+            timeout = self.timeout
+            
+        wait = WebDriverWait(driver, timeout)
+        return wait.until(EC.presence_of_all_elements_located((by, selector)))
+    
+    def _scroll_to_load_more(self, driver, scroll_count: int = 5, scroll_pause: float = 2.0):
+        """
+        Scroll down the page to load more content.
+        
+        Args:
+            driver: WebDriver instance
+            scroll_count: Number of times to scroll
+            scroll_pause: Pause between scrolls in seconds
+        """
+        for i in range(scroll_count):
+            # Scroll down to bottom
+            driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
+            
+            # Wait to load page
+            time.sleep(scroll_pause)
+            
+            # Log progress
+            logger.debug(f"Completed scroll {i+1}/{scroll_count}")
+            
+    def _extract_ad_details(self, ad_element) -> Dict[str, Any]:
+        """
+        Extract detailed information from an ad element.
+        
+        Args:
+            ad_element: WebElement containing the ad
+            
+        Returns:
+            Dictionary with ad details
+        """
+        ad_data = {
+            "scrape_time": datetime.now().isoformat(),
+            "platform": "facebook",
+            "raw_text": ad_element.text
+        }
+        
+        try:
+            # Try to extract advertiser name
+            advertiser_elem = ad_element.find_elements(By.CSS_SELECTOR, "span[dir='auto']")
+            if advertiser_elem:
+                ad_data["advertiser"] = advertiser_elem[0].text
+                
+            # Try to extract ad content
+            content_elem = ad_element.find_elements(By.CSS_SELECTOR, "div[dir='auto']")
+            if content_elem:
+                ad_data["content"] = "\n".join([elem.text for elem in content_elem])
+                
+            # Try to extract images
+            img_elems = ad_element.find_elements(By.TAG_NAME, "img")
+            if img_elems:
+                ad_data["images"] = [img.get_attribute("src") for img in img_elems if img.get_attribute("src")]
+                
+            # Try to extract links
+            link_elems = ad_element.find_elements(By.TAG_NAME, "a")
+            if link_elems:
+                ad_data["links"] = [link.get_attribute("href") for link in link_elems if link.get_attribute("href")]
+                
+            # Try to extract ad ID from URL
+            if "links" in ad_data and ad_data["links"]:
+                for link in ad_data["links"]:
+                    id_match = re.search(r'id=(\d+)', link)
+                    if id_match:
+                        ad_data["ad_id"] = id_match.group(1)
+                        break
+                        
+        except Exception as e:
+            logger.warning(f"Error extracting ad details: {e}")
+            
+        return ad_data
+    
+    def scrape_ads(self, search_query: str, num_scrolls: int = 5, country_code: str = "ALL") -> List[Dict[str, Any]]:
+        """
+        Scrape ads from Facebook Ads Library based on a search query.
+        
+        Args:
+            search_query: Keyword to search for
+            num_scrolls: Number of times to scroll to load more ads
+            country_code: Country code filter (e.g., "US", "GB", "ALL")
+            
+        Returns:
+            List of dictionaries containing ad information
+        """
+        with self._get_driver() as driver:
+            try:
+                # Construct URL with parameters
+                url = f"https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country={country_code}&q={search_query}&search_type=keyword"
+                logger.info(f"Accessing Facebook Ads Library: {url}")
+                
+                # Navigate to the URL
+                driver.get(url)
+                
+                # Wait for initial content to load
+                try:
+                    self._wait_for_element(driver, "div[role='main']")
+                except TimeoutException:
+                    logger.warning("Timeout waiting for main content to load")
+                
+                # Scroll to load more ads
+                self._scroll_to_load_more(driver, num_scrolls)
+                
+                # Find all ad elements
+                # Try multiple selectors as Facebook might change their structure
+                selectors = [
+                    "div.x1yztbdb",  # Current selector
+                    "div[role='article']",  # Alternative selector
+                    "div.x1iorvi4"  # Another possible selector
+                ]
+                
+                ad_elements = []
+                for selector in selectors:
+                    try:
+                        elements = driver.find_elements(By.CSS_SELECTOR, selector)
+                        if elements:
+                            ad_elements = elements
+                            logger.info(f"Found {len(elements)} ads using selector: {selector}")
+                            break
+                    except Exception as e:
+                        logger.debug(f"Selector {selector} failed: {e}")
+                
+                if not ad_elements:
+                    logger.warning("No ad elements found with any selector")
+                    return []
+                
+                # Extract detailed information from each ad
+                ads_data = []
+                for i, ad_element in enumerate(ad_elements):
+                    try:
+                        ad_data = self._extract_ad_details(ad_element)
+                        ad_data["position"] = i + 1
+                        ad_data["search_query"] = search_query
+                        ads_data.append(ad_data)
+                    except Exception as e:
+                        logger.error(f"Error processing ad {i+1}: {e}")
+                
+                logger.info(f"Successfully scraped {len(ads_data)} ads")
+                return ads_data
+                
+            except (TimeoutException, WebDriverException) as e:
+                logger.error(f"Error during scraping: {e}")
+                return []
+    
+    def scrape_advertiser_details(self, advertiser_id: str) -> Dict[str, Any]:
+        """
+        Scrape details about a specific advertiser.
+        
+        Args:
+            advertiser_id: Facebook ID of the advertiser
+            
+        Returns:
+            Dictionary with advertiser information
+        """
+        with self._get_driver() as driver:
+            try:
+                url = f"https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=ALL&view_all_page_id={advertiser_id}"
+                logger.info(f"Accessing advertiser page: {url}")
+                
+                driver.get(url)
+                
+                # Wait for page to load
+                try:
+                    self._wait_for_element(driver, "div[role='main']")
+                except TimeoutException:
+                    logger.warning("Timeout waiting for advertiser page to load")
+                
+                # Extract advertiser information
+                advertiser_data = {
+                    "id": advertiser_id,
+                    "scrape_time": datetime.now().isoformat()
+                }
+                
+                # Try to get advertiser name
+                try:
+                    name_elem = self._wait_for_element(driver, "div[role='main'] h1", timeout=5)
+                    advertiser_data["name"] = name_elem.text
+                except:
+                    pass
+                
+                # Try to get ad count
+                try:
+                    count_text = driver.find_element(By.XPATH, "//div[contains(text(), 'ads')]").text
+                    count_match = re.search(r'(\d+)\s+ads', count_text)
+                    if count_match:
+                        advertiser_data["ad_count"] = int(count_match.group(1))
+                except:
+                    pass
+                
+                # Scroll to load some ads
+                self._scroll_to_load_more(driver, 3)
+                
+                # Get sample ads
+                ad_elements = driver.find_elements(By.CSS_SELECTOR, "div.x1yztbdb")
+                sample_ads = []
+                
+                for i, ad_element in enumerate(ad_elements[:5]):  # Get up to 5 sample ads
+                    try:
+                        ad_data = self._extract_ad_details(ad_element)
+                        sample_ads.append(ad_data)
+                    except Exception as e:
+                        logger.error(f"Error processing sample ad {i+1}: {e}")
+                
+                advertiser_data["sample_ads"] = sample_ads
+                advertiser_data["sample_ad_count"] = len(sample_ads)
+                
+                return advertiser_data
+                
+            except Exception as e:
+                logger.error(f"Error scraping advertiser details: {e}")
+                return {"id": advertiser_id, "error": str(e)}
+    
+    def scrape_ads_by_topic(self, topic: str, num_scrolls: int = 5, country_code: str = "ALL") -> List[Dict[str, Any]]:
+        """
+        Scrape ads related to a specific topic.
+        
+        Args:
+            topic: Topic to search for (e.g., "politics", "health", "finance")
+            num_scrolls: Number of times to scroll to load more ads
+            country_code: Country code filter
+            
+        Returns:
+            List of dictionaries containing ad information
+        """
+        # This is essentially the same as scrape_ads but with a different name for clarity
+        return self.scrape_ads(topic, num_scrolls, country_code)
+    
+    def scrape_ads_by_page(self, page_name: str, num_scrolls: int = 5) -> List[Dict[str, Any]]:
+        """
+        Scrape ads from a specific Facebook page.
+        
+        Args:
+            page_name: Name of the Facebook page
+            num_scrolls: Number of times to scroll to load more ads
+            
+        Returns:
+            List of dictionaries containing ad information
+        """
+        with self._get_driver() as driver:
+            try:
+                # First, try to find the page ID
+                search_url = f"https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=ALL&q={page_name}&search_type=page"
+                logger.info(f"Searching for page: {search_url}")
+                
+                driver.get(search_url)
+                
+                # Wait for search results
+                try:
+                    self._wait_for_element(driver, "div[role='main']")
+                except TimeoutException:
+                    logger.warning("Timeout waiting for page search results")
+                
+                # Try to find and click on the first page result
+                try:
+                    page_links = driver.find_elements(By.CSS_SELECTOR, "a[href*='view_all_page_id=']")
+                    if page_links:
+                        # Extract page ID from URL
+                        href = page_links[0].get_attribute("href")
+                        page_id_match = re.search(r'view_all_page_id=(\d+)', href)
+                        
+                        if page_id_match:
+                            page_id = page_id_match.group(1)
+                            logger.info(f"Found page ID: {page_id}")
+                            
+                            # Navigate directly to page's ads
+                            page_url = f"https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=ALL&view_all_page_id={page_id}"
+                            driver.get(page_url)
+                            
+                            # Wait for page to load
+                            try:
+                                self._wait_for_element(driver, "div[role='main']")
+                            except TimeoutException:
+                                logger.warning("Timeout waiting for page ads to load")
+                            
+                            # Scroll to load more ads
+                            self._scroll_to_load_more(driver, num_scrolls)
+                            
+                            # Find all ad elements
+                            ad_elements = driver.find_elements(By.CSS_SELECTOR, "div.x1yztbdb")
+                            
+                            # Extract detailed information from each ad
+                            ads_data = []
+                            for i, ad_element in enumerate(ad_elements):
+                                try:
+                                    ad_data = self._extract_ad_details(ad_element)
+                                    ad_data["position"] = i + 1
+                                    ad_data["page_name"] = page_name
+                                    ad_data["page_id"] = page_id
+                                    ads_data.append(ad_data)
+                                except Exception as e:
+                                    logger.error(f"Error processing ad {i+1}: {e}")
+                            
+                            logger.info(f"Successfully scraped {len(ads_data)} ads from page {page_name}")
+                            return ads_data
+                except Exception as e:
+                    logger.error(f"Error finding page: {e}")
+                
+                # If we couldn't find the page, fall back to regular search
+                logger.warning(f"Could not find page {page_name}, falling back to keyword search")
+                return self.scrape_ads(page_name, num_scrolls)
+                
+            except Exception as e:
+                logger.error(f"Error during page scraping: {e}")
+                return [] 

app/templates/base.html

@@ -3,11 +3,12 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>{% block title %}Facebook Ad Analytics{% endblock %}</title>
+    <title>{% block title %}Facebook Ad Analytics{% endblock %} - Ad Analysis Tool</title>
     <!-- Bootstrap CSS -->
     <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/css/bootstrap.min.css" rel="stylesheet">
     <!-- Custom CSS -->
     <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" rel="stylesheet">
     {% block head_extra %}{% endblock %}
 </head>
 <body>
@@ -26,7 +27,14 @@
                         <a class="nav-link" href="{{ url_for('google_ads.index') }}">Google Ads</a>
                     </li>
                     <li class="nav-item">
-                        <a class="nav-link" href="{{ url_for('compliance.compliance_report') }}">Compliance</a>
+                        <a class="nav-link" href="{{ url_for('facebook_ads.index') }}">
+                            <i class="fab fa-facebook"></i> Facebook Ads
+                        </a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link" href="{{ url_for('compliance.compliance_report') }}">
+                            <i class="fas fa-check-circle"></i> Compliance
+                        </a>
                     </li>
                 </ul>
                 <ul class="navbar-nav">

app/templates/facebook_ads/ad_analysis.html

@@ -0,0 +1,123 @@
+{% extends "base.html" %}
+
+{% block title %}Ad Analysis - {{ ad.advertiser }}{% endblock %}
+
+{% block content %}
+<div class="container mt-4">
+    <nav aria-label="breadcrumb">
+        <ol class="breadcrumb">
+            <li class="breadcrumb-item"><a href="{{ url_for('facebook_ads.index') }}">Dashboard</a></li>
+            <li class="breadcrumb-item"><a href="{{ url_for('facebook_ads.results') }}">Results</a></li>
+            <li class="breadcrumb-item"><a href="{{ url_for('facebook_ads.view_ad', ad_id=ad.id) }}">Ad Details</a></li>
+            <li class="breadcrumb-item active" aria-current="page">Analysis</li>
+        </ol>
+    </nav>
+    
+    <div class="card mb-4">
+        <div class="card-header">
+            <h2 class="mb-0">Ad Analysis</h2>
+        </div>
+        <div class="card-body">
+            <div class="row mb-4">
+                <div class="col-md-12">
+                    <h4>Original Content</h4>
+                    <p class="lead">{{ ad.content }}</p>
+                </div>
+            </div>
+            
+            <div class="row">
+                <div class="col-md-6">
+                    <div class="card mb-4">
+                        <div class="card-body">
+                            <h4>Sentiment Analysis</h4>
+                            {% if ad.sentiment is not none %}
+                                <div class="progress mb-3">
+                                    {% set sentiment_percent = ((ad.sentiment + 1) / 2) * 100 %}
+                                    <div class="progress-bar bg-{{ 'success' if ad.sentiment > 0 else 'danger' if ad.sentiment < 0 else 'secondary' }}"
+                                         role="progressbar"
+                                         style="width: {{ sentiment_percent }}%"
+                                         aria-valuenow="{{ sentiment_percent }}"
+                                         aria-valuemin="0"
+                                         aria-valuemax="100">
+                                        {{ "Positive" if ad.sentiment > 0 else "Negative" if ad.sentiment < 0 else "Neutral" }}
+                                    </div>
+                                </div>
+                                <p>
+                                    <strong>Score:</strong> {{ "%.2f"|format(ad.sentiment) }}<br>
+                                    <small class="text-muted">
+                                        Scores range from -1 (very negative) to +1 (very positive)
+                                    </small>
+                                </p>
+                            {% else %}
+                                <div class="alert alert-info">
+                                    Sentiment analysis is in progress...
+                                </div>
+                            {% endif %}
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="col-md-6">
+                    <div class="card mb-4">
+                        <div class="card-body">
+                            <h4>Topics</h4>
+                            {% if ad.topics %}
+                                <div class="mb-3">
+                                    {% for topic in ad.topics %}
+                                        <span class="badge bg-info me-2 mb-2">{{ topic }}</span>
+                                    {% endfor %}
+                                </div>
+                                <small class="text-muted">
+                                    Topics are extracted using natural language processing
+                                </small>
+                            {% else %}
+                                <div class="alert alert-info">
+                                    Topic analysis is in progress...
+                                </div>
+                            {% endif %}
+                        </div>
+                    </div>
+                </div>
+            </div>
+            
+            {% if ad.entities %}
+                <div class="card mb-4">
+                    <div class="card-body">
+                        <h4>Named Entities</h4>
+                        <div class="table-responsive">
+                            <table class="table table-striped">
+                                <thead>
+                                    <tr>
+                                        <th>Entity</th>
+                                        <th>Type</th>
+                                        <th>Description</th>
+                                    </tr>
+                                </thead>
+                                <tbody>
+                                    {% for entity in ad.entities %}
+                                        <tr>
+                                            <td>{{ entity.text }}</td>
+                                            <td><span class="badge bg-secondary">{{ entity.type }}</span></td>
+                                            <td>{{ entity.description or 'N/A' }}</td>
+                                        </tr>
+                                    {% endfor %}
+                                </tbody>
+                            </table>
+                        </div>
+                        <small class="text-muted">
+                            Named entities are important words or phrases that represent specific concepts
+                        </small>
+                    </div>
+                </div>
+            {% endif %}
+            
+            {% if not ad.sentiment or not ad.topics %}
+                <div class="alert alert-warning">
+                    <h4 class="alert-heading">Analysis in Progress</h4>
+                    <p>The ad content is being analyzed. This process may take a few moments. Please refresh the page to see updated results.</p>
+                </div>
+            {% endif %}
+        </div>
+    </div>
+</div>
+{% endblock %} 

app/templates/facebook_ads/ad_detail.html

@@ -0,0 +1,129 @@
+{% extends "base.html" %}
+
+{% block title %}Facebook Ad Details{% endblock %}
+
+{% block content %}
+<div class="container mt-4">
+    <nav aria-label="breadcrumb">
+        <ol class="breadcrumb">
+            <li class="breadcrumb-item"><a href="{{ url_for('facebook_ads.index') }}">Dashboard</a></li>
+            <li class="breadcrumb-item"><a href="{{ url_for('facebook_ads.results') }}">Results</a></li>
+            <li class="breadcrumb-item active" aria-current="page">Ad Details</li>
+        </ol>
+    </nav>
+    
+    <div class="card mb-4">
+        <div class="card-header">
+            <h2 class="mb-0">
+                <a href="{{ url_for('facebook_ads.advertiser_detail', advertiser_name=ad.advertiser) }}">
+                    {{ ad.advertiser }}
+                </a>
+            </h2>
+        </div>
+        <div class="card-body">
+            {% if ad.image_urls %}
+                <div class="row mb-4">
+                    {% for image_url in ad.image_urls %}
+                        <div class="col-md-6 mb-3">
+                            <img src="{{ image_url }}" class="img-fluid rounded" alt="Ad Image {{ loop.index }}">
+                        </div>
+                    {% endfor %}
+                </div>
+            {% endif %}
+            
+            <div class="mb-4">
+                <h4>Ad Content</h4>
+                <p class="lead">{{ ad.content }}</p>
+            </div>
+            
+            {% if ad.links %}
+                <div class="mb-4">
+                    <h4>Links</h4>
+                    <ul class="list-group">
+                        {% for link in ad.links %}
+                            <li class="list-group-item">
+                                <a href="{{ link }}" target="_blank" rel="noopener noreferrer">{{ link }}</a>
+                            </li>
+                        {% endfor %}
+                    </ul>
+                </div>
+            {% endif %}
+            
+            <div class="row">
+                <div class="col-md-6">
+                    {% if ad.sentiment is not none %}
+                        <div class="mb-4">
+                            <h4>Sentiment Analysis</h4>
+                            <div class="progress">
+                                {% set sentiment_percent = ((ad.sentiment + 1) / 2) * 100 %}
+                                <div class="progress-bar bg-{{ 'success' if ad.sentiment > 0 else 'danger' if ad.sentiment < 0 else 'secondary' }}"
+                                     role="progressbar"
+                                     style="width: {{ sentiment_percent }}%"
+                                     aria-valuenow="{{ sentiment_percent }}"
+                                     aria-valuemin="0"
+                                     aria-valuemax="100">
+                                    {{ "Positive" if ad.sentiment > 0 else "Negative" if ad.sentiment < 0 else "Neutral" }}
+                                </div>
+                            </div>
+                            <small class="text-muted">Score: {{ "%.2f"|format(ad.sentiment) }}</small>
+                        </div>
+                    {% endif %}
+                </div>
+                
+                <div class="col-md-6">
+                    {% if ad.topics %}
+                        <div class="mb-4">
+                            <h4>Topics</h4>
+                            {% for topic in ad.topics %}
+                                <span class="badge bg-info me-2 mb-2">{{ topic }}</span>
+                            {% endfor %}
+                        </div>
+                    {% endif %}
+                </div>
+            </div>
+            
+            {% if ad.entities %}
+                <div class="mb-4">
+                    <h4>Entities</h4>
+                    <div class="table-responsive">
+                        <table class="table table-striped">
+                            <thead>
+                                <tr>
+                                    <th>Entity</th>
+                                    <th>Type</th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {% for entity in ad.entities %}
+                                    <tr>
+                                        <td>{{ entity.text }}</td>
+                                        <td><span class="badge bg-secondary">{{ entity.type }}</span></td>
+                                    </tr>
+                                {% endfor %}
+                            </tbody>
+                        </table>
+                    </div>
+                </div>
+            {% endif %}
+            
+            {% if not ad.sentiment or not ad.topics %}
+                <div class="mt-4">
+                    <a href="{{ url_for('facebook_ads.analyze_ad', ad_id=ad.id) }}" class="btn btn-primary">
+                        Analyze Ad Content
+                    </a>
+                </div>
+            {% endif %}
+        </div>
+        <div class="card-footer text-muted">
+            <div class="row">
+                <div class="col-md-6">
+                    Scraped: {{ ad.created_at.strftime('%Y-%m-%d %H:%M:%S') }}
+                </div>
+                <div class="col-md-6 text-end">
+                    Search Query: {{ ad.search_query or 'N/A' }}
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+{% endblock %} 

app/templates/facebook_ads/advertiser_detail.html

@@ -0,0 +1,141 @@
+{% extends "base.html" %}
+
+{% block title %}{{ advertiser }} - Facebook Ads{% endblock %}
+
+{% block content %}
+<div class="container mt-4">
+    <nav aria-label="breadcrumb">
+        <ol class="breadcrumb">
+            <li class="breadcrumb-item"><a href="{{ url_for('facebook_ads.index') }}">Dashboard</a></li>
+            <li class="breadcrumb-item"><a href="{{ url_for('facebook_ads.advertisers') }}">Advertisers</a></li>
+            <li class="breadcrumb-item active" aria-current="page">{{ advertiser }}</li>
+        </ol>
+    </nav>
+    
+    <div class="row mb-4">
+        <div class="col">
+            <h1>{{ advertiser }}</h1>
+        </div>
+        <div class="col-auto">
+            <a href="{{ url_for('facebook_ads.page_search') }}?page_name={{ advertiser }}" 
+               class="btn btn-primary">
+                Scrape More Ads
+            </a>
+        </div>
+    </div>
+    
+    {% if ads %}
+        <div class="row">
+            <div class="col-md-4 mb-4">
+                <div class="card">
+                    <div class="card-body">
+                        <h5 class="card-title">Statistics</h5>
+                        <ul class="list-unstyled">
+                            <li>Total Ads: {{ ads|length }}</li>
+                            <li>First Ad: {{ ads[-1].created_at.strftime('%Y-%m-%d') }}</li>
+                            <li>Latest Ad: {{ ads[0].created_at.strftime('%Y-%m-%d') }}</li>
+                        </ul>
+                    </div>
+                </div>
+            </div>
+            
+            <div class="col-md-8 mb-4">
+                <div class="card">
+                    <div class="card-body">
+                        <h5 class="card-title">Sentiment Overview</h5>
+                        {% set positive = namespace(count=0) %}
+                        {% set negative = namespace(count=0) %}
+                        {% set neutral = namespace(count=0) %}
+                        {% for ad in ads %}
+                            {% if ad.sentiment is not none %}
+                                {% if ad.sentiment > 0 %}
+                                    {% set positive.count = positive.count + 1 %}
+                                {% elif ad.sentiment < 0 %}
+                                    {% set negative.count = negative.count + 1 %}
+                                {% else %}
+                                    {% set neutral.count = neutral.count + 1 %}
+                                {% endif %}
+                            {% endif %}
+                        {% endfor %}
+                        
+                        <div class="progress">
+                            {% set total = positive.count + negative.count + neutral.count %}
+                            {% if total > 0 %}
+                                <div class="progress-bar bg-success" role="progressbar" 
+                                     style="width: {{ (positive.count / total * 100)|round }}%">
+                                    {{ positive.count }}
+                                </div>
+                                <div class="progress-bar bg-secondary" role="progressbar" 
+                                     style="width: {{ (neutral.count / total * 100)|round }}%">
+                                    {{ neutral.count }}
+                                </div>
+                                <div class="progress-bar bg-danger" role="progressbar" 
+                                     style="width: {{ (negative.count / total * 100)|round }}%">
+                                    {{ negative.count }}
+                                </div>
+                            {% endif %}
+                        </div>
+                        <div class="mt-2">
+                            <small class="text-muted">
+                                Positive: {{ positive.count }}, 
+                                Neutral: {{ neutral.count }}, 
+                                Negative: {{ negative.count }}
+                            </small>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <div class="row">
+            {% for ad in ads %}
+                <div class="col-md-6 mb-4">
+                    <div class="card h-100">
+                        <div class="card-body">
+                            {% if ad.image_urls %}
+                                <div class="mb-3">
+                                    <img src="{{ ad.image_urls[0] }}" class="img-fluid rounded" alt="Ad Image">
+                                </div>
+                            {% endif %}
+                            
+                            <p class="card-text">{{ ad.content[:200] }}{% if ad.content|length > 200 %}...{% endif %}</p>
+                            
+                            {% if ad.sentiment %}
+                                <div class="mb-2">
+                                    <strong>Sentiment:</strong>
+                                    <span class="badge bg-{{ 'success' if ad.sentiment > 0 else 'danger' if ad.sentiment < 0 else 'secondary' }}">
+                                        {{ "Positive" if ad.sentiment > 0 else "Negative" if ad.sentiment < 0 else "Neutral" }}
+                                    </span>
+                                </div>
+                            {% endif %}
+                            
+                            {% if ad.topics %}
+                                <div class="mb-2">
+                                    <strong>Topics:</strong>
+                                    {% for topic in ad.topics %}
+                                        <span class="badge bg-info me-1">{{ topic }}</span>
+                                    {% endfor %}
+                                </div>
+                            {% endif %}
+                            
+                            <div class="mt-3">
+                                <a href="{{ url_for('facebook_ads.view_ad', ad_id=ad.id) }}" class="btn btn-primary btn-sm">View Details</a>
+                                {% if not ad.sentiment or not ad.topics %}
+                                    <a href="{{ url_for('facebook_ads.analyze_ad', ad_id=ad.id) }}" class="btn btn-secondary btn-sm">Analyze</a>
+                                {% endif %}
+                            </div>
+                        </div>
+                        <div class="card-footer text-muted">
+                            {{ ad.created_at.strftime('%Y-%m-%d %H:%M:%S') }}
+                        </div>
+                    </div>
+                </div>
+            {% endfor %}
+        </div>
+    {% else %}
+        <div class="alert alert-info" role="alert">
+            No ads found for this advertiser. Try <a href="{{ url_for('facebook_ads.page_search') }}?page_name={{ advertiser }}">scraping more ads</a>.
+        </div>
+    {% endif %}
+</div>
+{% endblock %} 

app/templates/facebook_ads/advertisers.html

@@ -0,0 +1,43 @@
+{% extends "base.html" %}
+
+{% block title %}Facebook Advertisers{% endblock %}
+
+{% block content %}
+<div class="container mt-4">
+    <h1 class="mb-4">Facebook Advertisers</h1>
+    
+    {% if advertisers %}
+        <div class="card">
+            <div class="card-body">
+                <div class="table-responsive">
+                    <table class="table table-striped table-hover">
+                        <thead>
+                            <tr>
+                                <th>Advertiser</th>
+                                <th>Number of Ads</th>
+                                <th>Actions</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {% for advertiser in advertisers %}
+                                <tr>
+                                    <td>{{ advertiser[0] }}</td>
+                                    <td>{{ advertiser[1] }}</td>
+                                    <td>
+                                        <a href="{{ url_for('facebook_ads.advertiser_detail', advertiser_name=advertiser[0]) }}" 
+                                           class="btn btn-primary btn-sm">View Ads</a>
+                                    </td>
+                                </tr>
+                            {% endfor %}
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+    {% else %}
+        <div class="alert alert-info" role="alert">
+            No advertisers found. Try <a href="{{ url_for('facebook_ads.search') }}">searching for ads</a> first.
+        </div>
+    {% endif %}
+</div>
+{% endblock %} 

app/templates/facebook_ads/index.html

@@ -0,0 +1,53 @@
+{% extends "base.html" %}
+
+{% block title %}Facebook Ads Dashboard{% endblock %}
+
+{% block content %}
+<div class="container mt-4">
+    <h1 class="mb-4">Facebook Ads Dashboard</h1>
+    
+    <div class="row">
+        <div class="col-md-6">
+            <div class="card mb-4">
+                <div class="card-body">
+                    <h5 class="card-title">Search Ads</h5>
+                    <p class="card-text">Search for Facebook ads using keywords and filters.</p>
+                    <a href="{{ url_for('facebook_ads.search') }}" class="btn btn-primary">Search Ads</a>
+                </div>
+            </div>
+        </div>
+        
+        <div class="col-md-6">
+            <div class="card mb-4">
+                <div class="card-body">
+                    <h5 class="card-title">Page Search</h5>
+                    <p class="card-text">Search for ads from specific Facebook pages.</p>
+                    <a href="{{ url_for('facebook_ads.page_search') }}" class="btn btn-primary">Search by Page</a>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <div class="row">
+        <div class="col-md-6">
+            <div class="card mb-4">
+                <div class="card-body">
+                    <h5 class="card-title">View Results</h5>
+                    <p class="card-text">Browse and analyze collected Facebook ads.</p>
+                    <a href="{{ url_for('facebook_ads.results') }}" class="btn btn-primary">View Results</a>
+                </div>
+            </div>
+        </div>
+        
+        <div class="col-md-6">
+            <div class="card mb-4">
+                <div class="card-body">
+                    <h5 class="card-title">Advertisers</h5>
+                    <p class="card-text">View and analyze advertisers and their ads.</p>
+                    <a href="{{ url_for('facebook_ads.advertisers') }}" class="btn btn-primary">View Advertisers</a>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+{% endblock %} 

app/templates/facebook_ads/page_search.html

@@ -0,0 +1,52 @@
+{% extends "base.html" %}
+
+{% block title %}Search Facebook Page Ads{% endblock %}
+
+{% block content %}
+<div class="container mt-4">
+    <h1 class="mb-4">Search Facebook Page Ads</h1>
+    
+    <div class="card mb-4">
+        <div class="card-body">
+            <form method="POST" action="{{ url_for('facebook_ads.page_search') }}">
+                {{ form.csrf_token }}
+                <div class="mb-3">
+                    <label for="page_name" class="form-label">Facebook Page Name</label>
+                    <input type="text" class="form-control" id="page_name" name="page_name" required
+                           placeholder="Enter the Facebook page name or URL">
+                    <small class="text-muted">Example: cocacola or https://www.facebook.com/cocacola</small>
+                </div>
+                
+                <div class="mb-3">
+                    <label for="num_scrolls" class="form-label">Number of Scrolls</label>
+                    <input type="number" class="form-control" id="num_scrolls" name="num_scrolls" 
+                           value="5" min="1" max="50">
+                    <small class="text-muted">More scrolls = more ads, but takes longer to scrape</small>
+                </div>
+                
+                <button type="submit" class="btn btn-primary">Search Page Ads</button>
+                <a href="{{ url_for('facebook_ads.index') }}" class="btn btn-secondary">Back to Dashboard</a>
+            </form>
+        </div>
+    </div>
+    
+    {% if task_id %}
+    <div class="alert alert-info" role="alert">
+        <h4 class="alert-heading">Scraping in Progress!</h4>
+        <p>Your page search request is being processed. This may take a few minutes depending on the number of scrolls.</p>
+        <hr>
+        <p class="mb-0">You can view the results on the <a href="{{ url_for('facebook_ads.results') }}">Results page</a> once the scraping is complete.</p>
+    </div>
+    {% endif %}
+    
+    {% with messages = get_flashed_messages(with_categories=true) %}
+        {% if messages %}
+            {% for category, message in messages %}
+                <div class="alert alert-{{ category }}" role="alert">
+                    {{ message }}
+                </div>
+            {% endfor %}
+        {% endif %}
+    {% endwith %}
+</div>
+{% endblock %} 

app/templates/facebook_ads/results.html

@@ -0,0 +1,87 @@
+{% extends "base.html" %}
+
+{% block title %}Facebook Ads Results{% endblock %}
+
+{% block content %}
+<div class="container mt-4">
+    <h1 class="mb-4">Facebook Ads Results</h1>
+    
+    <div class="card mb-4">
+        <div class="card-body">
+            <form method="GET" action="{{ url_for('facebook_ads.results') }}" class="row g-3">
+                <div class="col-md-4">
+                    <label for="query" class="form-label">Search Query</label>
+                    <input type="text" class="form-control" id="query" name="query" value="{{ query }}">
+                </div>
+                <div class="col-md-4">
+                    <label for="advertiser" class="form-label">Advertiser</label>
+                    <input type="text" class="form-control" id="advertiser" name="advertiser" value="{{ advertiser }}">
+                </div>
+                <div class="col-md-4">
+                    <label class="form-label">&nbsp;</label>
+                    <div>
+                        <button type="submit" class="btn btn-primary">Filter</button>
+                        <a href="{{ url_for('facebook_ads.results') }}" class="btn btn-secondary">Clear Filters</a>
+                    </div>
+                </div>
+            </form>
+        </div>
+    </div>
+    
+    {% if ads %}
+        <div class="row">
+            {% for ad in ads %}
+                <div class="col-md-6 mb-4">
+                    <div class="card h-100">
+                        <div class="card-body">
+                            <h5 class="card-title">
+                                <a href="{{ url_for('facebook_ads.advertiser_detail', advertiser_name=ad.advertiser) }}">
+                                    {{ ad.advertiser }}
+                                </a>
+                            </h5>
+                            
+                            {% if ad.image_urls %}
+                                <div class="mb-3">
+                                    <img src="{{ ad.image_urls[0] }}" class="img-fluid rounded" alt="Ad Image">
+                                </div>
+                            {% endif %}
+                            
+                            <p class="card-text">{{ ad.content[:200] }}{% if ad.content|length > 200 %}...{% endif %}</p>
+                            
+                            {% if ad.sentiment %}
+                                <div class="mb-2">
+                                    <strong>Sentiment:</strong>
+                                    <span class="badge bg-{{ 'success' if ad.sentiment > 0 else 'danger' if ad.sentiment < 0 else 'secondary' }}">
+                                        {{ "Positive" if ad.sentiment > 0 else "Negative" if ad.sentiment < 0 else "Neutral" }}
+                                    </span>
+                                </div>
+                            {% endif %}
+                            
+                            {% if ad.topics %}
+                                <div class="mb-2">
+                                    <strong>Topics:</strong>
+                                    {% for topic in ad.topics %}
+                                        <span class="badge bg-info me-1">{{ topic }}</span>
+                                    {% endfor %}
+                                </div>
+                            {% endif %}
+                            
+                            <div class="mt-3">
+                                <a href="{{ url_for('facebook_ads.view_ad', ad_id=ad.id) }}" class="btn btn-primary btn-sm">View Details</a>
+                                <a href="{{ url_for('facebook_ads.analyze_ad', ad_id=ad.id) }}" class="btn btn-secondary btn-sm">Analyze</a>
+                            </div>
+                        </div>
+                        <div class="card-footer text-muted">
+                            Scraped: {{ ad.created_at.strftime('%Y-%m-%d %H:%M:%S') }}
+                        </div>
+                    </div>
+                </div>
+            {% endfor %}
+        </div>
+    {% else %}
+        <div class="alert alert-info" role="alert">
+            No ads found. Try adjusting your search filters or <a href="{{ url_for('facebook_ads.search') }}">search for new ads</a>.
+        </div>
+    {% endif %}
+</div>
+{% endblock %} 

app/templates/facebook_ads/search.html

@@ -0,0 +1,63 @@
+{% extends "base.html" %}
+
+{% block title %}Search Facebook Ads{% endblock %}
+
+{% block content %}
+<div class="container mt-4">
+    <h1 class="mb-4">Search Facebook Ads</h1>
+    
+    <div class="card mb-4">
+        <div class="card-body">
+            <form method="POST" action="{{ url_for('facebook_ads.search') }}">
+                {{ form.csrf_token }}
+                <div class="mb-3">
+                    <label for="search_query" class="form-label">Search Query</label>
+                    <input type="text" class="form-control" id="search_query" name="search_query" required
+                           placeholder="Enter keywords to search for ads">
+                </div>
+                
+                <div class="mb-3">
+                    <label for="num_scrolls" class="form-label">Number of Scrolls</label>
+                    <input type="number" class="form-control" id="num_scrolls" name="num_scrolls" 
+                           value="5" min="1" max="50">
+                    <small class="text-muted">More scrolls = more ads, but takes longer to scrape</small>
+                </div>
+                
+                <div class="mb-3">
+                    <label for="country_code" class="form-label">Country</label>
+                    <select class="form-control" id="country_code" name="country_code">
+                        <option value="ALL">All Countries</option>
+                        <option value="US">United States</option>
+                        <option value="GB">United Kingdom</option>
+                        <option value="CA">Canada</option>
+                        <option value="AU">Australia</option>
+                        <!-- Add more countries as needed -->
+                    </select>
+                </div>
+                
+                <button type="submit" class="btn btn-primary">Search Ads</button>
+                <a href="{{ url_for('facebook_ads.index') }}" class="btn btn-secondary">Back to Dashboard</a>
+            </form>
+        </div>
+    </div>
+    
+    {% if task_id %}
+    <div class="alert alert-info" role="alert">
+        <h4 class="alert-heading">Scraping in Progress!</h4>
+        <p>Your search request is being processed. This may take a few minutes depending on the number of scrolls.</p>
+        <hr>
+        <p class="mb-0">You can view the results on the <a href="{{ url_for('facebook_ads.results') }}">Results page</a> once the scraping is complete.</p>
+    </div>
+    {% endif %}
+    
+    {% with messages = get_flashed_messages(with_categories=true) %}
+        {% if messages %}
+            {% for category, message in messages %}
+                <div class="alert alert-{{ category }}" role="alert">
+                    {{ message }}
+                </div>
+            {% endfor %}
+        {% endif %}
+    {% endwith %}
+</div>
+{% endblock %} 

app/templates/login.html

@@ -1,15 +1,28 @@
 {% extends "base.html" %}
 
 {% block content %}
-<h2>Login</h2>
-<form method="POST" action="{{ url_for('auth.login') }}">
-    <label for="email">Email:</label>
-    <input type="email" id="email" name="email" required>
-    
-    <label for="password">Password:</label>
-    <input type="password" id="password" name="password" required>
-    
-    <button type="submit">Login</button>
-</form>
-<p>Don't have an account? <a href="{{ url_for('auth.register') }}">Register here</a>.</p>
+<div class="container mt-5">
+    <div class="row justify-content-center">
+        <div class="col-md-6">
+            <div class="card">
+                <div class="card-header">Login</div>
+                <div class="card-body">
+                    <form method="POST" action="{{ url_for('auth.login') }}">
+                        {{ form.hidden_tag() }}
+                        <div class="form-group">
+                            {{ form.email.label }} {{ form.email(class="form-control") }}
+                        </div>
+                        <div class="form-group">
+                            {{ form.password.label }} {{ form.password(class="form-control") }}
+                        </div>
+                        <button type="submit" class="btn btn-primary">Login</button>
+                    </form>
+                    <div class="mt-3">
+                        <p>Don't have an account? <a href="{{ url_for('auth.register') }}">Register here</a>.</p>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
 {% endblock %}

config.py

@@ -7,10 +7,13 @@ class Config:
     if SECRET_KEY == 'dev-secret-key-change-in-production':
         print("WARNING: Using default SECRET_KEY. This is insecure and should be changed in production.")
     
-    SQLALCHEMY_DATABASE_URI = os.getenv('DATABASE_URL', 'sqlite:////tmp/app.db')
+    # Use SQLite for simplicity
+    SQLALCHEMY_DATABASE_URI = os.getenv('DATABASE_URL', 'sqlite:///app.db')
     SQLALCHEMY_TRACK_MODIFICATIONS = False
-    CELERY_BROKER_URL = os.getenv('CELERY_BROKER_URL', 'redis://localhost:6379/0')
-    CELERY_RESULT_BACKEND = os.getenv('CELERY_RESULT_BACKEND', 'redis://localhost:6379/0')
+    
+    # Use SQLite for Celery broker instead of Redis
+    CELERY_BROKER_URL = os.getenv('CELERY_BROKER_URL', 'sqla+sqlite:///celery.db')
+    CELERY_RESULT_BACKEND = os.getenv('CELERY_RESULT_BACKEND', 'db+sqlite:///celery-results.db')
     
     # Use a mock API key for development if not provided
     OPENAI_API_KEY = os.getenv('OPENAI_API_KEY', 'sk-mock-key-for-development')

migrations/README

@@ -0,0 +1 @@
+Single-database configuration for Flask.

migrations/alembic.ini

@@ -0,0 +1,50 @@
+# A generic, single database configuration.
+
+[alembic]
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic,flask_migrate
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[logger_flask_migrate]
+level = INFO
+handlers =
+qualname = flask_migrate
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

migrations/env.py

@@ -0,0 +1,113 @@
+import logging
+from logging.config import fileConfig
+
+from flask import current_app
+
+from alembic import context
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+fileConfig(config.config_file_name)
+logger = logging.getLogger('alembic.env')
+
+
+def get_engine():
+    try:
+        # this works with Flask-SQLAlchemy<3 and Alchemical
+        return current_app.extensions['migrate'].db.get_engine()
+    except (TypeError, AttributeError):
+        # this works with Flask-SQLAlchemy>=3
+        return current_app.extensions['migrate'].db.engine
+
+
+def get_engine_url():
+    try:
+        return get_engine().url.render_as_string(hide_password=False).replace(
+            '%', '%%')
+    except AttributeError:
+        return str(get_engine().url).replace('%', '%%')
+
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+config.set_main_option('sqlalchemy.url', get_engine_url())
+target_db = current_app.extensions['migrate'].db
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def get_metadata():
+    if hasattr(target_db, 'metadatas'):
+        return target_db.metadatas[None]
+    return target_db.metadata
+
+
+def run_migrations_offline():
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url, target_metadata=get_metadata(), literal_binds=True
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online():
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+
+    # this callback is used to prevent an auto-migration from being generated
+    # when there are no changes to the schema
+    # reference: http://alembic.zzzcomputing.com/en/latest/cookbook.html
+    def process_revision_directives(context, revision, directives):
+        if getattr(config.cmd_opts, 'autogenerate', False):
+            script = directives[0]
+            if script.upgrade_ops.is_empty():
+                directives[:] = []
+                logger.info('No changes in schema detected.')
+
+    conf_args = current_app.extensions['migrate'].configure_args
+    if conf_args.get("process_revision_directives") is None:
+        conf_args["process_revision_directives"] = process_revision_directives
+
+    connectable = get_engine()
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=get_metadata(),
+            **conf_args
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

migrations/script.py.mako

@@ -0,0 +1,24 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade():
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+    ${downgrades if downgrades else "pass"}

migrations/versions/dddcd665398d_add_facebook_ad_table.py

@@ -0,0 +1,60 @@
+"""Add facebook_ad table
+
+Revision ID: dddcd665398d
+Revises: 
+Create Date: 2025-03-10 09:02:26.975759
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'dddcd665398d'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('facebook_ad',
+    sa.Column('id', sa.String(length=36), nullable=False),
+    sa.Column('ad_id', sa.String(length=255), nullable=True),
+    sa.Column('advertiser', sa.String(length=255), nullable=True),
+    sa.Column('advertiser_id', sa.String(length=255), nullable=True),
+    sa.Column('content', sa.Text(), nullable=True),
+    sa.Column('images', sa.JSON(), nullable=True),
+    sa.Column('links', sa.JSON(), nullable=True),
+    sa.Column('search_query', sa.String(length=255), nullable=True),
+    sa.Column('position', sa.Integer(), nullable=True),
+    sa.Column('sentiment', sa.JSON(), nullable=True),
+    sa.Column('topics', sa.JSON(), nullable=True),
+    sa.Column('entities', sa.JSON(), nullable=True),
+    sa.Column('raw_data', sa.JSON(), nullable=True),
+    sa.Column('raw_text', sa.Text(), nullable=True),
+    sa.Column('created_at', sa.DateTime(), nullable=True),
+    sa.Column('updated_at', sa.DateTime(), nullable=True),
+    sa.Column('user_id', sa.Integer(), nullable=True),
+    sa.ForeignKeyConstraint(['user_id'], ['user.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    with op.batch_alter_table('facebook_ad', schema=None) as batch_op:
+        batch_op.create_index(batch_op.f('ix_facebook_ad_ad_id'), ['ad_id'], unique=False)
+        batch_op.create_index(batch_op.f('ix_facebook_ad_advertiser'), ['advertiser'], unique=False)
+        batch_op.create_index(batch_op.f('ix_facebook_ad_advertiser_id'), ['advertiser_id'], unique=False)
+        batch_op.create_index(batch_op.f('ix_facebook_ad_search_query'), ['search_query'], unique=False)
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('facebook_ad', schema=None) as batch_op:
+        batch_op.drop_index(batch_op.f('ix_facebook_ad_search_query'))
+        batch_op.drop_index(batch_op.f('ix_facebook_ad_advertiser_id'))
+        batch_op.drop_index(batch_op.f('ix_facebook_ad_advertiser'))
+        batch_op.drop_index(batch_op.f('ix_facebook_ad_ad_id'))
+
+    op.drop_table('facebook_ad')
+    # ### end Alembic commands ###

requirements.txt

@@ -1,22 +1,21 @@
-Flask==2.3.2
-Flask-SQLAlchemy==3.0.5
-Flask-Login==0.6.2
-Flask-WTF==1.1.1
-Flask-Migrate==4.0.4
-Werkzeug==2.3.7
-celery==5.3.1
-redis==5.0.0
-selenium==4.10.0
-transformers==4.31.0
-numpy<2.0.0
-opencv-python==4.8.0.76
-pytesseract==0.3.10
-gunicorn==20.1.0
-pytest==7.4.0
-prophet==1.1.4
-webdriver-manager==4.0.0
-psycopg2-binary==2.9.6
-click==8.1.3
-python-dotenv==1.0.0
-ratelimit==2.2.1
-torch==2.0.1
+Flask==3.0.0
+Flask-SQLAlchemy==3.1.1
+Flask-Login==0.6.3
+Flask-Migrate==4.0.5
+Flask-WTF==1.2.1
+email_validator==2.1.0.post1
+celery==5.3.6
+redis==5.0.1
+alembic==1.13.1
+python-dotenv==1.0.1
+gunicorn==21.2.0
+psycopg2-binary==2.9.9
+requests==2.31.0
+beautifulsoup4==4.12.3
+selenium==4.17.2
+transformers==4.37.2
+torch==2.1.2
+textblob==0.17.1
+spacy==3.7.2
+en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl
+webdriver-manager==4.0.1