Saving local changes before rebase

.env.example

@@ -0,0 +1,6 @@
+FLASK_APP=app.py
+FLASK_ENV=development
+SECRET_KEY=your-secret-key-here
+DATABASE_URL=postgresql://user:password@localhost:5432/dbname
+REDIS_URL=redis://localhost:6379/0
+SELENIUM_HUB_URL=http://selenium-hub:4444/wd/hub

.gitignore

@@ -0,0 +1,3 @@
+# YOLO model files
+app/models/*.weights
+app/models/*.cfg 

Dockerfile

@@ -0,0 +1,56 @@
+FROM python:3.9-slim
+
+# Set environment variables
+ENV FLASK_APP=app.py
+ENV FLASK_ENV=production
+ENV PATH="/home/appuser/.local/bin:$PATH"
+ENV PYTHONUNBUFFERED=1
+
+# Install system dependencies for OpenCV and other requirements
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    tesseract-ocr \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create a non-root user
+RUN useradd -m appuser && mkdir -p /app /app/instance /app/models && chown -R appuser:appuser /app
+
+# Set the working directory
+WORKDIR /app
+
+# Copy requirements and install dependencies
+COPY --chown=appuser:appuser requirements.txt .
+
+# Install dependencies with proper error handling
+RUN pip install --no-cache-dir "numpy<2.0.0" && \
+    pip install --no-cache-dir -r requirements.txt && \
+    # Verify critical packages are installed
+    python -c "import flask, flask_sqlalchemy, redis, celery; print('All critical dependencies installed successfully')"
+
+# Download YOLO files
+RUN wget https://github.com/AlexeyAB/darknet/releases/download/darknet_yolo_v3_optimal/yolov4.weights -O /app/models/yolov4.weights && \
+    wget https://raw.githubusercontent.com/AlexeyAB/darknet/master/cfg/yolov4.cfg -O /app/models/yolov4.cfg && \
+    chown appuser:appuser /app/models/yolov4.*
+
+# Create a health check script
+RUN echo '#!/bin/sh\npython -c "import flask, flask_sqlalchemy, redis, celery; print(\"Dependencies OK\")"' > /app/healthcheck.sh
+
+# Copy the application code
+COPY --chown=appuser:appuser . .
+
+# Make scripts executable
+RUN chmod +x /app/prestart.sh /app/healthcheck.sh
+
+# Switch to non-root user
+USER appuser
+
+# Expose the port
+EXPOSE 5000
+
+# Run the prestart script and then start the application
+CMD ["/bin/bash", "-c", "/app/prestart.sh && gunicorn --config=./gunicorn.conf.py --workers=2 app:create_app()"]

README.md

@@ -1,12 +1,139 @@
 ---
-title: Fb
-emoji: 📊
-colorFrom: red
-colorTo: yellow
-sdk: docker
-pinned: false
 license: apache-2.0
-short_description: ads analitics
+title: Facebook Ad Analytics
+sdk: docker
+emoji: 📊
+colorFrom: green
+colorTo: blue
+pinned: true
+short_description: facebook-ad-analytics
 ---
+# Facebook Ad Analytics
+
+A comprehensive tool for scraping, analyzing, and visualizing Facebook ads using AI and machine learning.
+
+## Features
+- **Ad Scraping**: Scrape Facebook ads using Selenium.
+- **Sentiment Analysis**: Analyze ad sentiment using AI (Hugging Face Transformers).
+- **Image Analysis**: Extract text from images (OCR) and detect objects using YOLOv4.
+- **Compliance Reporting**: Generate compliance reports and anonymize ads.
+- **Predictive Analytics**: Forecast ad performance using machine learning.
+- **Google Ads Analysis**: Scrape and analyze Google Search and Display ads.
+
+## Requirements
+- Python 3.9+
+- PostgreSQL (recommended for production)
+- Redis (for Celery task queue)
+- Tesseract OCR
+
+## Setup
+
+### Quick Setup
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/yourusername/facebook-ad-analytics.git
+   cd facebook-ad-analytics
+   ```
+
+2. Run the setup script:
+   ```bash
+   python setup.py
+   ```
+
+3. Update the `.env` file with your settings.
+
+4. Run the application:
+   ```bash
+   python manage.py run
+   ```
+
+### Manual Setup
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/yourusername/facebook-ad-analytics.git
+   cd facebook-ad-analytics
+   ```
+
+2. Create a virtual environment and install dependencies:
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   pip install -r requirements.txt
+   ```
+
+3. Copy the example environment file and update it:
+   ```bash
+   cp .env.example .env
+   # Edit .env with your settings
+   ```
+
+4. Initialize the database:
+   ```bash
+   python manage.py init-db
+   ```
+
+5. Download YOLOv4 models:
+   ```bash
+   mkdir -p app/models
+   wget https://github.com/AlexeyAB/darknet/releases/download/darknet_yolo_v3_optimal/yolov4.weights -O app/models/yolov4.weights
+   wget https://raw.githubusercontent.com/AlexeyAB/darknet/master/cfg/yolov4.cfg -O app/models/yolov4.cfg
+   ```
+
+6. Run the application:
+   ```bash
+   python manage.py run
+   ```
+
+## Docker Deployment
+For production deployment, use Docker Compose:
+
+```bash
+# Set environment variables in .env file first
+docker-compose up -d
+```
+
+## Troubleshooting
+
+### Missing Dependencies
+If you encounter errors about missing dependencies, run the dependency checker:
+
+```bash
+python check_dependencies.py
+```
+
+This will identify any missing packages. You can install them with:
+
+```bash
+pip install -r requirements.txt
+```
+
+### Common Issues
+
+#### ModuleNotFoundError: No module named 'ratelimit'
+This error occurs when the ratelimit package is missing. Install it with:
+
+```bash
+pip install ratelimit
+```
+
+#### AI Model Warnings
+Warnings about missing PyTorch, TensorFlow, or Flax are normal if you don't need the full AI capabilities. For full functionality, install:
+
+```bash
+pip install torch==2.0.1
+```
+
+## Testing
+Run the test suite:
+```bash
+python manage.py test
+```
+
+## API Documentation
+The API endpoints are available at `/api/v1/` and include:
+- `/api/v1/ads` - List and create ads
+- `/api/v1/ads/<id>` - Get, update, or delete an ad
+- `/api/v1/analyze` - Analyze ad content
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## License
+This project is licensed under the Apache 2.0 License - see the LICENSE file for details.

app.py

@@ -0,0 +1,6 @@
+from flask import Flask
+
+def create_app():
+    app = Flask(__name__)
+    app.config['INSTANCE_PATH'] = '/tmp/instance'  # Ensure this path exists
+    return app

app/__init__.py

@@ -0,0 +1,37 @@
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+from flask_login import LoginManager
+from celery import Celery
+import redis
+
+db = SQLAlchemy()
+login = LoginManager()
+celery = Celery(__name__)
+cache = redis.Redis()
+
+def create_app():
+    # Create the Flask app first
+    app = Flask(__name__)
+
+    # Load configuration
+    app.config.from_object('config.Config')
+
+    # Set the instance path after loading the config
+    app.instance_path = app.config['INSTANCE_PATH']
+
+    # Initialize extensions
+    db.init_app(app)
+    login.init_app(app)
+    celery.conf.update(app.config)
+    
+    # Register Blueprints
+    from .routes.auth import auth_bp
+    from .routes.dashboard import dashboard_bp
+    from .routes.api import api_bp
+    from .routes.compliance import compliance_bp
+    app.register_blueprint(auth_bp)
+    app.register_blueprint(dashboard_bp)
+    app.register_blueprint(api_bp)
+    app.register_blueprint(compliance_bp)
+    
+    return app

app/forms.py

@@ -0,0 +1,15 @@
+from flask_wtf import FlaskForm
+from wtforms import StringField, PasswordField, SubmitField
+from wtforms.validators import DataRequired, Email, EqualTo
+
+class LoginForm(FlaskForm):
+    email = StringField('Email', validators=[DataRequired(), Email()])
+    password = PasswordField('Password', validators=[DataRequired()])
+    submit = SubmitField('Login')
+
+class RegistrationForm(FlaskForm):
+    email = StringField('Email', validators=[DataRequired(), Email()])
+    password = PasswordField('Password', validators=[DataRequired()])
+    password2 = PasswordField(
+        'Repeat Password', validators=[DataRequired(), EqualTo('password')])
+    submit = SubmitField('Register') 

app/models.py

@@ -0,0 +1,22 @@
+from . import db
+from datetime import datetime
+
+class User(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    email = db.Column(db.String(120), unique=True, nullable=False)
+    password = db.Column(db.String(128), nullable=False)
+    role = db.Column(db.String(20), default="viewer")
+
+class Ad(db.Model):
+    id = db.Column(db.UUID, primary_key=True)
+    content = db.Column(db.Text)
+    sentiment = db.Column(db.JSON)
+    ad_metadata = db.Column(db.JSON)
+    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
+    versions = db.relationship('AdVersion', backref='ad')
+
+class AdVersion(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    ad_id = db.Column(db.UUID, db.ForeignKey('ad.id'))
+    content = db.Column(db.Text)
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow)

app/routes/__init__.py

@@ -0,0 +1 @@
+# Empty file to make the directory a package

app/routes/api.py

@@ -0,0 +1,61 @@
+from flask import Blueprint, jsonify, request
+from flask_login import login_required
+from ..models import Ad
+from ..services.ai_processor import AIPipeline
+from ..utils.validators import validate_request_json
+from ..utils.decorators import cache_response
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Try to import ratelimit, but provide a fallback if it's not available
+try:
+    from ratelimit import limits, RateLimitException
+    RATELIMIT_AVAILABLE = True
+    logger.info("Rate limiting is enabled")
+except ImportError:
+    logger.warning("ratelimit package not found. Rate limiting is disabled.")
+    RATELIMIT_AVAILABLE = False
+    
+    # Define fallback decorator and exception
+    def limits(calls, period):
+        def decorator(f):
+            return f
+        return decorator
+    
+    class RateLimitException(Exception):
+        pass
+
+api_bp = Blueprint('api', __name__)
+
+ONE_MINUTE = 60
+MAX_REQUESTS_PER_MINUTE = 30
+
+@api_bp.route('/ads', methods=['GET'])
+@login_required
+def get_ads():
+    ads = Ad.query.all()
+    return jsonify([{
+        'id': ad.id,
+        'content': ad.content,
+        'sentiment': ad.sentiment
+    } for ad in ads])
+
+@api_bp.route('/analyze', methods=['POST'])
+@login_required
+@limits(calls=MAX_REQUESTS_PER_MINUTE, period=ONE_MINUTE)
+def analyze_ad():
+    validation_error = validate_request_json(['text'])
+    if validation_error:
+        return validation_error
+        
+    try:
+        data = request.json
+        ad_text = data['text']
+        ai = AIPipeline()
+        result = ai.process_ad(ad_text)
+        return jsonify(result)
+    except RateLimitException:
+        return jsonify({"error": "Rate limit exceeded"}), 429
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500

app/routes/auth.py

@@ -0,0 +1,35 @@
+from flask import Blueprint, render_template, redirect, url_for, flash
+from flask_login import login_user, logout_user, login_required
+from ..models import User
+from ..forms import LoginForm, RegistrationForm
+
+auth_bp = Blueprint('auth', __name__)
+
+@auth_bp.route('/login', methods=['GET', 'POST'])
+def login():
+    form = LoginForm()
+    if form.validate_on_submit():
+        user = User.query.filter_by(email=form.email.data).first()
+        if user and user.check_password(form.password.data):
+            login_user(user)
+            return redirect(url_for('dashboard.index'))
+        flash('Invalid email or password')
+    return render_template('login.html', form=form)
+
+@auth_bp.route('/logout')
+@login_required
+def logout():
+    logout_user()
+    return redirect(url_for('auth.login'))
+
+@auth_bp.route('/register', methods=['GET', 'POST'])
+def register():
+    form = RegistrationForm()
+    if form.validate_on_submit():
+        user = User(email=form.email.data)
+        user.set_password(form.password.data)
+        db.session.add(user)
+        db.session.commit()
+        flash('Registration successful!')
+        return redirect(url_for('auth.login'))
+    return render_template('register.html', form=form)

app/routes/compliance.py

@@ -0,0 +1,27 @@
+from flask import Blueprint, render_template, request, jsonify
+from flask_login import login_required
+from ..models import Ad
+from ..utils.decorators import admin_required
+from .. import db
+
+compliance_bp = Blueprint('compliance', __name__)
+
+@compliance_bp.route('/report')
+@login_required
+@admin_required
+def compliance_report():
+    ads = Ad.query.all()
+    return render_template('compliance_report.html', ads=ads)
+
+@compliance_bp.route('/anonymize/<ad_id>', methods=['POST'])
+@login_required
+@admin_required
+def anonymize_ad(ad_id):
+    try:
+        ad = Ad.query.get_or_404(ad_id)
+        ad.content = "REDACTED"
+        db.session.commit()
+        return jsonify({'status': 'success'})
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'status': 'error', 'message': str(e)}), 500

app/routes/dashboard.py

@@ -0,0 +1,21 @@
+from flask import Blueprint, render_template, request
+from flask_login import login_required
+from ..models import Ad
+from ..services.ai_processor import AIPipeline
+
+dashboard_bp = Blueprint('dashboard', __name__)
+
+@dashboard_bp.route('/')
+@login_required
+def index():
+    page = request.args.get('page', 1, type=int)
+    per_page = 10
+    query = request.args.get('query', '')
+    sentiment_filter = request.args.get('sentiment', '')
+    
+    ads = Ad.query.filter(
+        Ad.content.contains(query),
+        Ad.sentiment.contains(sentiment_filter)
+    ).paginate(page=page, per_page=per_page)
+    
+    return render_template('dashboard.html', ads=ads, query=query, sentiment_filter=sentiment_filter)

app/scripts/setup_yolo.py

@@ -0,0 +1,57 @@
+import urllib.request
+import os
+from pathlib import Path
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+YOLO_CONFIG = {
+    'weights': {
+        'url': 'https://github.com/AlexeyAB/darknet/releases/download/darknet_yolo_v3_optimal/yolov4.weights',
+        'filename': 'yolov4.weights'
+    },
+    'config': {
+        'url': 'https://raw.githubusercontent.com/AlexeyAB/darknet/master/cfg/yolov4.cfg',
+        'filename': 'yolov4.cfg'
+    }
+}
+
+def download_file(url: str, filename: str):
+    """Download a file and show progress."""
+    try:
+        logger.info(f"Downloading {filename}...")
+        
+        def report_progress(count, block_size, total_size):
+            percent = int(count * block_size * 100 / total_size)
+            print(f"\rProgress: {percent}%", end='')
+            
+        filepath = Path('app/models') / filename
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        
+        urllib.request.urlretrieve(
+            url,
+            filepath,
+            reporthook=report_progress
+        )
+        print()  # New line after progress
+        logger.info(f"Successfully downloaded {filename}")
+        return True
+    except Exception as e:
+        logger.error(f"Error downloading {filename}: {e}")
+        return False
+
+def setup_yolo():
+    """Download and set up YOLO files."""
+    success = True
+    for file_info in YOLO_CONFIG.values():
+        if not download_file(file_info['url'], file_info['filename']):
+            success = False
+    
+    if success:
+        logger.info("YOLO setup completed successfully!")
+    else:
+        logger.error("YOLO setup failed. Please check the errors above.")
+
+if __name__ == "__main__":
+    setup_yolo() 

app/services/ai_processor.py

@@ -0,0 +1,66 @@
+import cv2
+import pytesseract
+from transformers import pipeline
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+class AIPipeline:
+    def __init__(self):
+        try:
+            self.nlp = pipeline("text-classification", model="roberta-base")
+            
+            model_dir = Path("app/models")
+            weights_path = model_dir / "yolov4.weights"
+            config_path = model_dir / "yolov4.cfg"
+            
+            if not (weights_path.exists() and config_path.exists()):
+                logger.warning("YOLOv4 files not found. Please run setup_yolo.py first.")
+                self.detector = None
+            else:
+                self.detector = cv2.dnn.readNet(str(weights_path), str(config_path))
+                
+        except Exception as e:
+            logger.error(f"Error initializing AI Pipeline: {e}")
+            raise
+
+    def process_ad(self, ad):
+        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
+        except Exception as e:
+            logger.error(f"Error processing ad: {e}")
+            return {"error": str(e)}
+
+    def _analyze_sentiment(self, text):
+        try:
+            return self.nlp(text)[0] if text else None
+        except Exception as e:
+            logger.error(f"Sentiment analysis error: {e}")
+            return None
+
+    def _extract_ocr(self, media):
+        if not media or not hasattr(media, 'type') or media.type != "image":
+            return None
+        try:
+            return pytesseract.image_to_string(media.path)
+        except Exception as e:
+            logger.error(f"OCR error: {e}")
+            return None
+
+    def _detect_objects(self, media):
+        if not media or not hasattr(media, 'type') or media.type != "image" or not self.detector:
+            return None
+        try:
+            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()
+        except Exception as e:
+            logger.error(f"Object detection error: {e}")
+            return None

app/services/blockchain.py

@@ -0,0 +1,29 @@
+from hashlib import sha256
+import time
+
+class AdBlockchain:
+    def __init__(self):
+        self.chain = []
+        self.create_block(proof=1, previous_hash='0')
+        
+    def create_block(self, proof, previous_hash, ad_data=None):
+        block = {
+            'index': len(self.chain) + 1,
+            'timestamp': str(time.time()),
+            'proof': proof,
+            'previous_hash': previous_hash,
+            'ad_hash': self.hash_ad(ad_data)
+        }
+        self.chain.append(block)
+        return block
+    
+    def hash_ad(self, ad_data):
+        return sha256(str(ad_data).encode()).hexdigest()
+
+    def is_chain_valid(self):
+        for i in range(1, len(self.chain)):
+            current_block = self.chain[i]
+            previous_block = self.chain[i - 1]
+            if current_block['previous_hash'] != self.hash_ad(previous_block):
+                return False
+        return True

app/services/plugin_manager.py

@@ -0,0 +1,20 @@
+import importlib.util
+from pathlib import Path
+
+class PluginManager:
+    def __init__(self):
+        self.plugins = {}
+        
+    def load_plugins(self, directory="plugins"):
+        for plugin_file in Path(directory).glob("*.py"):
+            spec = importlib.util.spec_from_file_location(plugin_file.stem, plugin_file)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            self.plugins[plugin_file.stem] = module
+            
+    def run_analysis(self, ad):
+        results = {}
+        for name, plugin in self.plugins.items():
+            if hasattr(plugin, "analyze"):
+                results[name] = plugin.analyze(ad)
+        return results

app/services/predictive.py

@@ -0,0 +1,16 @@
+from prophet import Prophet
+import numpy as np
+from sklearn.linear_model import LinearRegression
+
+class AdPredictor:
+    def forecast_performance(self, historical_data):
+        model = Prophet()
+        model.fit(historical_data)
+        future = model.make_future_dataframe(periods=30)
+        return model.predict(future)
+    
+    def simulate_budget(self, current_spend, current_performance, proposed_spend):
+        X = np.array([current_spend]).reshape(-1, 1)
+        y = np.array([current_performance])
+        model = LinearRegression().fit(X, y)
+        return model.predict([[proposed_spend]])

app/services/scraper.py

@@ -0,0 +1,46 @@
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.chrome.service import Service
+from webdriver_manager.chrome import ChromeDriverManager
+import time
+from selenium.common.exceptions import TimeoutException, WebDriverException
+from contextlib import contextmanager
+
+class FacebookScraper:
+    def __init__(self):
+        self.driver = None
+
+    def _setup_driver(self):
+        options = webdriver.ChromeOptions()
+        options.add_argument("--headless")
+        options.add_argument("--no-sandbox")
+        options.add_argument("--disable-dev-shm-usage")
+        return webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
+
+    @contextmanager
+    def _get_driver(self):
+        try:
+            self.driver = self._setup_driver()
+            yield self.driver
+        finally:
+            if self.driver:
+                self.driver.quit()
+
+    def scrape_ads(self, search_query, num_scrolls=3):
+        with self._get_driver() as driver:
+            try:
+                url = f"https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=ALL&q={search_query}&search_type=keyword"
+                driver.get(url)
+                driver.implicitly_wait(5)
+
+                ads = []
+                for _ in range(num_scrolls):
+                    driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
+                    time.sleep(3)
+                
+                ad_elements = driver.find_elements(By.CSS_SELECTOR, "div.x1yztbdb")
+                return [ad.text for ad in ad_elements if ad.text]
+                
+            except (TimeoutException, WebDriverException) as e:
+                print(f"Error during scraping: {e}")
+                return []

app/static/css/styles.css

@@ -0,0 +1,160 @@
+/* General Styles */
+body {
+    font-family: Arial, sans-serif;
+    margin: 0;
+    padding: 0;
+    background-color: #f4f4f9;
+    color: #333;
+}
+
+header {
+    background-color: #0073e6;
+    color: white;
+    padding: 1rem;
+    text-align: center;
+}
+
+header h1 {
+    margin: 0;
+}
+
+nav {
+    margin-top: 1rem;
+}
+
+nav a {
+    color: white;
+    margin: 0 1rem;
+    text-decoration: none;
+    font-weight: bold;
+}
+
+nav a:hover {
+    text-decoration: underline;
+}
+
+main {
+    padding: 2rem;
+}
+
+footer {
+    background-color: #333;
+    color: white;
+    text-align: center;
+    padding: 1rem;
+    position: fixed;
+    bottom: 0;
+    width: 100%;
+}
+
+/* Dashboard Styles */
+.filters {
+    margin-bottom: 2rem;
+}
+
+.filters input, .filters select {
+    padding: 0.5rem;
+    margin-right: 1rem;
+    border: 1px solid #ccc;
+    border-radius: 4px;
+}
+
+.filters button {
+    padding: 0.5rem 1rem;
+    background-color: #0073e6;
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+}
+
+.filters button:hover {
+    background-color: #005bb5;
+}
+
+.ads-list {
+    display: grid;
+    gap: 1rem;
+}
+
+.ad-card {
+    background-color: white;
+    padding: 1rem;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.ad-card .sentiment {
+    display: inline-block;
+    padding: 0.25rem 0.5rem;
+    border-radius: 4px;
+    font-size: 0.875rem;
+}
+
+.ad-card .sentiment.Positive {
+    background-color: #e6f4ea;
+    color: #34a853;
+}
+
+.ad-card .sentiment.Negative {
+    background-color: #fce8e6;
+    color: #d93025;
+}
+
+.pagination {
+    margin-top: 2rem;
+    text-align: center;
+}
+
+.pagination a {
+    padding: 0.5rem 1rem;
+    margin: 0 0.25rem;
+    background-color: #0073e6;
+    color: white;
+    text-decoration: none;
+    border-radius: 4px;
+}
+
+.pagination a.active {
+    background-color: #005bb5;
+}
+
+/* Compliance Report Styles */
+table {
+    width: 100%;
+    border-collapse: collapse;
+    margin-top: 1rem;
+}
+
+table th, table td {
+    padding: 0.75rem;
+    border: 1px solid #ddd;
+    text-align: left;
+}
+
+table th {
+    background-color: #0073e6;
+    color: white;
+}
+
+table tr:nth-child(even) {
+    background-color: #f9f9f9;
+}
+
+table tr:hover {
+    background-color: #f1f1f1;
+}
+
+table button {
+    padding: 0.5rem 1rem;
+    background-color: #d93025;
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+}
+
+table button:hover {
+    background-color: #b31412;
+}

app/static/js/chart.js

@@ -0,0 +1,24 @@
+document.addEventListener("DOMContentLoaded", function () {
+    const ctx = document.getElementById('sentimentChart').getContext('2d');
+    const sentimentData = JSON.parse(document.getElementById('sentimentData').textContent);
+
+    new Chart(ctx, {
+        type: 'line',
+        data: {
+            labels: sentimentData.dates,
+            datasets: [{
+                label: 'Sentiment Trend',
+                data: sentimentData.scores,
+                borderColor: '#0073e6',
+                fill: false
+            }]
+        },
+        options: {
+            scales: {
+                y: {
+                    beginAtZero: true
+                }
+            }
+        }
+    });
+});

app/templates/base.html

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Facebook Ad Analytics</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+</head>
+<body>
+    <header>
+        <h1>Facebook Ad Analytics</h1>
+        <nav>
+            <a href="{{ url_for('dashboard.index') }}">Dashboard</a>
+            <a href="{{ url_for('compliance.compliance_report') }}">Compliance</a>
+            <a href="{{ url_for('auth.logout') }}">Logout</a>
+        </nav>
+    </header>
+    <main>
+        {% block content %}{% endblock %}
+    </main>
+    <footer>
+        <p>&copy; 2023 Facebook Ad Analytics</p>
+    </footer>
+</body>
+</html>

app/templates/compliance_report.html

@@ -0,0 +1,44 @@
+{% extends "base.html" %}
+
+{% block content %}
+<h2>Compliance Report</h2>
+<table>
+    <thead>
+        <tr>
+            <th>Ad ID</th>
+            <th>Content</th>
+            <th>Sentiment</th>
+            <th>Actions</th>
+        </tr>
+    </thead>
+    <tbody>
+        {% for ad in ads %}
+        <tr>
+            <td>{{ ad.id }}</td>
+            <td>{{ ad.content }}</td>
+            <td>{{ ad.sentiment }}</td>
+            <td>
+                <button onclick="anonymizeAd('{{ ad.id }}')">Anonymize</button>
+            </td>
+        </tr>
+        {% endfor %}
+    </tbody>
+</table>
+
+<script>
+    function anonymizeAd(adId) {
+        fetch(`/compliance/anonymize/${adId}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        }).then(response => response.json())
+          .then(data => {
+              if (data.status === 'success') {
+                  alert('Ad anonymized successfully!');
+                  location.reload();
+              }
+          });
+    }
+</script>
+{% endblock %}

app/templates/dashboard.html

@@ -0,0 +1,37 @@
+{% extends "base.html" %}
+
+{% block content %}
+<div class="filters">
+    <input type="text" name="query" placeholder="Search ads..." value="{{ query }}">
+    <select name="sentiment">
+        <option value="">All Sentiments</option>
+        <option value="Positive" {% if sentiment_filter == "Positive" %}selected{% endif %}>Positive</option>
+        <option value="Negative" {% if sentiment_filter == "Negative" %}selected{% endif %}>Negative</option>
+    </select>
+    <button type="button" onclick="applyFilters()">Apply</button>
+</div>
+
+<div class="ads-list">
+    {% for ad in ads.items %}
+    <div class="ad-card">
+        <p>{{ ad.content }}</p>
+        <span class="sentiment">{{ ad.sentiment }}</span>
+    </div>
+    {% endfor %}
+</div>
+
+<div class="pagination">
+    {% for p in range(1, ads.pages + 1) %}
+    <a href="?page={{ p }}&query={{ query }}&sentiment={{ sentiment_filter }}" 
+       class="{% if p == ads.page %}active{% endif %}">{{ p }}</a>
+    {% endfor %}
+</div>
+
+<script>
+    function applyFilters() {
+        const query = document.querySelector('input[name="query"]').value;
+        const sentiment = document.querySelector('select[name="sentiment"]').value;
+        window.location.href = `?query=${query}&sentiment=${sentiment}`;
+    }
+</script>
+{% endblock %}

app/templates/login.html

@@ -0,0 +1,15 @@
+{% 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>
+{% endblock %}

app/tests/__init__.py

@@ -0,0 +1 @@
+# Empty file to make the directory a package

app/tests/test_models.py

@@ -0,0 +1,26 @@
+import pytest
+from app.models import User, Ad, AdVersion
+from app import db
+
+@pytest.fixture
+def test_user():
+    user = User(email="test@example.com")
+    user.set_password("password123")
+    return user
+
+@pytest.fixture
+def test_ad(test_user):
+    return Ad(content="Test ad content", user_id=test_user.id)
+
+def test_user_creation(test_user):
+    assert test_user.email == "test@example.com"
+    assert test_user.check_password("password123")
+
+def test_ad_creation(test_ad):
+    assert test_ad.content == "Test ad content"
+    assert test_ad.user_id is not None
+
+def test_ad_version_creation(test_ad):
+    version = AdVersion(content="Updated ad content", ad_id=test_ad.id)
+    assert version.content == "Updated ad content"
+    assert version.ad_id == test_ad.id

app/tests/test_routes.py

@@ -0,0 +1,33 @@
+import pytest
+from flask import url_for
+from app import create_app, db
+from app.models import User, Ad
+
+@pytest.fixture
+def app():
+    app = create_app()
+    app.config.update({
+        'TESTING': True,
+        'SQLALCHEMY_DATABASE_URI': 'sqlite:///:memory:',
+        'WTF_CSRF_ENABLED': False
+    })
+    with app.app_context():
+        db.create_all()
+        yield app
+        db.drop_all()
+
+@pytest.fixture
+def client(app):
+    return app.test_client()
+
+def test_dashboard_route(client):
+    response = client.get(url_for('dashboard.index'))
+    assert response.status_code == 200
+
+def test_login_route(client):
+    response = client.get(url_for('auth.login'))
+    assert response.status_code == 200
+
+def test_compliance_report_route(client):
+    response = client.get(url_for('compliance.compliance_report'))
+    assert response.status_code == 302  # Redirects to login if not authenticated

app/tests/test_services.py

@@ -0,0 +1,20 @@
+import pytest
+from app.services.ai_processor import AIPipeline
+from app.services.scraper import FacebookScraper
+
+def test_ai_processor():
+    ai = AIPipeline()
+    result = ai.process_ad("This is a positive ad!")
+    assert "sentiment" in result
+
+def test_scraper():
+    scraper = FacebookScraper()
+    ads = scraper.scrape_ads("test query", num_scrolls=1)
+    assert isinstance(ads, list)
+
+def test_blockchain():
+    from app.services.blockchain import AdBlockchain
+    blockchain = AdBlockchain()
+    block = blockchain.create_block(proof=123, previous_hash="abc")
+    assert block["index"] == 2
+    assert blockchain.is_chain_valid()

app/utils/__init__.py

@@ -0,0 +1 @@
+# Empty file to make the directory a package

app/utils/decorators.py

@@ -0,0 +1,39 @@
+from functools import wraps
+from flask import redirect, url_for, flash
+from flask_login import current_user
+
+def admin_required(f):
+    """Decorator to restrict access to admin users only."""
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if not current_user.is_authenticated or current_user.role != "admin":
+            flash("You do not have permission to access this page.", "error")
+            return redirect(url_for("dashboard.index"))
+        return f(*args, **kwargs)
+    return decorated_function
+
+def login_required_json(f):
+    """Decorator to require login for JSON API endpoints."""
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if not current_user.is_authenticated:
+            return jsonify({"error": "Login required"}), 401
+        return f(*args, **kwargs)
+    return decorated_function
+
+def cache_response(timeout=60):
+    def decorator(f):
+        @wraps(f)
+        def decorated_function(*args, **kwargs):
+            from flask import request
+            from .. import cache
+            
+            cache_key = f"{request.path}:{request.query_string}"
+            cached_response = cache.get(cache_key)
+            if cached_response:
+                return cached_response
+            response = f(*args, **kwargs)
+            cache.set(cache_key, response, timeout=timeout)
+            return response
+        return decorated_function
+    return decorator

app/utils/helpers.py

@@ -0,0 +1,24 @@
+import re
+from datetime import datetime
+
+def format_date(date_str):
+    """Format a date string into a human-readable format."""
+    try:
+        date_obj = datetime.strptime(date_str, "%Y-%m-%d")
+        return date_obj.strftime("%b %d, %Y")
+    except ValueError:
+        return date_str
+
+def extract_hashtags(text):
+    """Extract hashtags from a given text."""
+    return re.findall(r"#\w+", text)
+
+def calculate_sentiment_score(sentiment_data):
+    """Calculate an overall sentiment score from sentiment data."""
+    if not sentiment_data:
+        return 0
+    return sum(sentiment_data.values()) / len(sentiment_data)
+
+def paginate(query, page, per_page=10):
+    """Paginate a SQLAlchemy query."""
+    return query.paginate(page=page, per_page=per_page, error_out=False)

app/utils/validators.py

@@ -0,0 +1,33 @@
+import re
+from flask import request, jsonify
+
+def validate_email(email):
+    """Validate an email address."""
+    regex = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
+    return re.match(regex, email) is not None
+
+def validate_password(password):
+    """Validate a password (at least 8 characters, one uppercase, one number)."""
+    if len(password) < 8:
+        return False
+    if not re.search(r"[A-Z]", password):
+        return False
+    if not re.search(r"\d", password):
+        return False
+    return True
+
+def validate_ad_content(content):
+    """Validate ad content (non-empty and within length limits)."""
+    if not content or len(content) > 1000:
+        return False
+    return True
+
+def validate_request_json(required_fields):
+    """Validate JSON request payload for required fields."""
+    data = request.get_json()
+    if not data:
+        return jsonify({"error": "Request must be JSON"}), 400
+    for field in required_fields:
+        if field not in data:
+            return jsonify({"error": f"Missing required field: {field}"}), 400
+    return None

celery_worker.py

@@ -0,0 +1,4 @@
+from app import create_app, celery
+
+app = create_app()
+app.app_context().push()

check_dependencies.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+"""
+Dependency checker script for Facebook Ad Analytics.
+This script checks if all required dependencies are installed.
+"""
+
+import importlib
+import sys
+
+REQUIRED_PACKAGES = [
+    "flask",
+    "flask_sqlalchemy",
+    "flask_login",
+    "flask_wtf",
+    "flask_migrate",
+    "werkzeug",
+    "celery",
+    "redis",
+    "selenium",
+    "transformers",
+    "numpy",
+    "cv2",  # OpenCV
+    "pytesseract",
+    "gunicorn",
+    "pytest",
+    "prophet",
+    "webdriver_manager",
+    "psycopg2",
+    "click",
+    "dotenv",
+    "ratelimit",
+]
+
+OPTIONAL_PACKAGES = [
+    "torch",
+    "tensorflow",
+    "flax",
+]
+
+def check_package(package_name):
+    """Check if a package is installed."""
+    try:
+        importlib.import_module(package_name)
+        return True
+    except ImportError:
+        return False
+
+def main():
+    """Main function."""
+    print("Checking required dependencies...")
+    missing_packages = []
+    
+    for package in REQUIRED_PACKAGES:
+        if not check_package(package):
+            missing_packages.append(package)
+            print(f"❌ {package} is not installed")
+        else:
+            print(f"✅ {package} is installed")
+    
+    print("\nChecking optional dependencies...")
+    missing_optional = []
+    
+    for package in OPTIONAL_PACKAGES:
+        if not check_package(package):
+            missing_optional.append(package)
+            print(f"⚠️ {package} is not installed (optional)")
+        else:
+            print(f"✅ {package} is installed")
+    
+    if missing_packages:
+        print(f"\n❌ {len(missing_packages)} required packages are missing:")
+        print("   " + ", ".join(missing_packages))
+        print("\nPlease install them using:")
+        print(f"pip install {' '.join(missing_packages)}")
+        return 1
+    else:
+        print("\n✅ All required packages are installed!")
+        
+        if missing_optional:
+            print(f"\n⚠️ {len(missing_optional)} optional packages are missing:")
+            print("   " + ", ".join(missing_optional))
+            print("\nYou may want to install them for full functionality:")
+            print(f"pip install {' '.join(missing_optional)}")
+        
+        return 0
+
+if __name__ == "__main__":
+    sys.exit(main()) 

config.py

@@ -0,0 +1,20 @@
+import os
+
+class Config:
+    SECRET_KEY = os.getenv('SECRET_KEY', 'your-secret-key')
+    SQLALCHEMY_DATABASE_URI = os.getenv('DATABASE_URL', 'sqlite:////tmp/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')
+    OPENAI_API_KEY = os.getenv('OPENAI_API_KEY', 'your-openai-api-key')
+    INSTANCE_PATH = '/tmp/instance'  # Set a writable instance path
+
+class DevelopmentConfig(Config):
+    DEBUG = True
+
+class ProductionConfig(Config):
+    DEBUG = False
+
+class TestingConfig(Config):
+    TESTING = True
+    SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'

docker-compose.yml

@@ -0,0 +1,97 @@
+version: '3.8'
+
+services:
+  web:
+    build: .
+    ports:
+      - "5000:5000"
+    environment:
+      - FLASK_ENV=production
+      - DATABASE_URL=postgresql://postgres:example@postgres:5432/facebook_ads
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+      - INSTANCE_PATH=/tmp/instance
+      - SECRET_KEY=${SECRET_KEY}
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+    volumes:
+      - ./app:/app/app
+      - ./app/models:/app/models
+    depends_on:
+      - redis
+      - postgres
+      - selenium-hub
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "/app/healthcheck.sh"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+
+  celery_worker:
+    build: .
+    command: celery -A celery_worker.celery worker --loglevel=info
+    environment:
+      - FLASK_ENV=production
+      - DATABASE_URL=postgresql://postgres:example@postgres:5432/facebook_ads
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+      - INSTANCE_PATH=/tmp/instance
+      - SECRET_KEY=${SECRET_KEY}
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+    volumes:
+      - ./app:/app/app
+    depends_on:
+      - web
+      - redis
+      - postgres
+    restart: unless-stopped
+
+  selenium-hub:
+    image: selenium/hub
+    ports:
+      - "4444:4444"
+    restart: unless-stopped
+
+  chrome-node:
+    image: selenium/node-chrome
+    shm_size: 2gb
+    depends_on:
+      - selenium-hub
+    environment:
+      - HUB_HOST=selenium-hub
+      - HUB_PORT=4444
+    restart: unless-stopped
+
+  redis:
+    image: redis:alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  postgres:
+    image: postgres:14
+    environment:
+      - POSTGRES_PASSWORD=example
+      - POSTGRES_DB=facebook_ads
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+volumes:
+  postgres_data:
+  redis_data:

gunicorn.conf.py

@@ -0,0 +1,29 @@
+# Force specific number of workers regardless of CPU count
+def get_workers():
+    return 2
+
+workers = get_workers()
+
+# Worker configuration
+worker_class = 'sync'
+timeout = 120
+graceful_timeout = 30
+keep_alive = 5
+
+# Request Handling
+max_requests = 1000
+max_requests_jitter = 50
+
+# Server Socket
+bind = '0.0.0.0:5000'
+
+# Logging
+loglevel = 'debug'
+accesslog = '-'
+errorlog = '-'
+capture_output = True
+
+# Ensure the configuration is not overridden
+def post_worker_init(worker):
+    import logging
+    logging.debug(f"Worker initialized with configuration: workers={workers}")

hf_env/Lib/site-packages/PyYAML-6.0.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

hf_env/Lib/site-packages/PyYAML-6.0.2.dist-info/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2017-2021 Ingy döt Net
+Copyright (c) 2006-2016 Kirill Simonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hf_env/Lib/site-packages/PyYAML-6.0.2.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.1
+Name: PyYAML
+Version: 6.0.2
+Summary: YAML parser and emitter for Python
+Home-page: https://pyyaml.org/
+Download-URL: https://pypi.org/project/PyYAML/
+Author: Kirill Simonov
+Author-email: xi@resolvent.net
+License: MIT
+Project-URL: Bug Tracker, https://github.com/yaml/pyyaml/issues
+Project-URL: CI, https://github.com/yaml/pyyaml/actions
+Project-URL: Documentation, https://pyyaml.org/wiki/PyYAMLDocumentation
+Project-URL: Mailing lists, http://lists.sourceforge.net/lists/listinfo/yaml-core
+Project-URL: Source Code, https://github.com/yaml/pyyaml
+Platform: Any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.8
+License-File: LICENSE
+
+YAML is a data serialization format designed for human readability
+and interaction with scripting languages.  PyYAML is a YAML parser
+and emitter for Python.
+
+PyYAML features a complete YAML 1.1 parser, Unicode support, pickle
+support, capable extension API, and sensible error messages.  PyYAML
+supports standard YAML tags and provides Python-specific tags that
+allow to represent an arbitrary Python object.
+
+PyYAML is applicable for a broad range of tasks from complex
+configuration files to object serialization and persistence.

hf_env/Lib/site-packages/PyYAML-6.0.2.dist-info/RECORD

@@ -0,0 +1,43 @@
+PyYAML-6.0.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+PyYAML-6.0.2.dist-info/LICENSE,sha256=jTko-dxEkP1jVwfLiOsmvXZBAqcoKVQwfT5RZ6V36KQ,1101
+PyYAML-6.0.2.dist-info/METADATA,sha256=9lwXqTOrXPts-jI2Lo5UwuaAYo0hiRA0BZqjch0WjAk,2106
+PyYAML-6.0.2.dist-info/RECORD,,
+PyYAML-6.0.2.dist-info/WHEEL,sha256=c7SWG1_hRvc9HXHEkmWlTu1Jr4WpzRucfzqTP-_8q0s,102
+PyYAML-6.0.2.dist-info/top_level.txt,sha256=rpj0IVMTisAjh_1vG3Ccf9v5jpCQwAz6cD1IVU5ZdhQ,11
+_yaml/__init__.py,sha256=04Ae_5osxahpJHa3XBZUAf4wi6XX32gR8D6X6p64GEA,1402
+_yaml/__pycache__/__init__.cpython-312.pyc,,
+yaml/__init__.py,sha256=N35S01HMesFTe0aRRMWkPj0Pa8IEbHpE9FK7cr5Bdtw,12311
+yaml/__pycache__/__init__.cpython-312.pyc,,
+yaml/__pycache__/composer.cpython-312.pyc,,
+yaml/__pycache__/constructor.cpython-312.pyc,,
+yaml/__pycache__/cyaml.cpython-312.pyc,,
+yaml/__pycache__/dumper.cpython-312.pyc,,
+yaml/__pycache__/emitter.cpython-312.pyc,,
+yaml/__pycache__/error.cpython-312.pyc,,
+yaml/__pycache__/events.cpython-312.pyc,,
+yaml/__pycache__/loader.cpython-312.pyc,,
+yaml/__pycache__/nodes.cpython-312.pyc,,
+yaml/__pycache__/parser.cpython-312.pyc,,
+yaml/__pycache__/reader.cpython-312.pyc,,
+yaml/__pycache__/representer.cpython-312.pyc,,
+yaml/__pycache__/resolver.cpython-312.pyc,,
+yaml/__pycache__/scanner.cpython-312.pyc,,
+yaml/__pycache__/serializer.cpython-312.pyc,,
+yaml/__pycache__/tokens.cpython-312.pyc,,
+yaml/_yaml.cp312-win_amd64.pyd,sha256=Bx7e_LEQx7cnd1_A9_nClp3X77g-_Lw1aoAAtYZbwWk,263680
+yaml/composer.py,sha256=_Ko30Wr6eDWUeUpauUGT3Lcg9QPBnOPVlTnIMRGJ9FM,4883
+yaml/constructor.py,sha256=kNgkfaeLUkwQYY_Q6Ff1Tz2XVw_pG1xVE9Ak7z-viLA,28639
+yaml/cyaml.py,sha256=6ZrAG9fAYvdVe2FK_w0hmXoG7ZYsoYUwapG8CiC72H0,3851
+yaml/dumper.py,sha256=PLctZlYwZLp7XmeUdwRuv4nYOZ2UBnDIUy8-lKfLF-o,2837
+yaml/emitter.py,sha256=jghtaU7eFwg31bG0B7RZea_29Adi9CKmXq_QjgQpCkQ,43006
+yaml/error.py,sha256=Ah9z-toHJUbE9j-M8YpxgSRM5CgLCcwVzJgLLRF2Fxo,2533
+yaml/events.py,sha256=50_TksgQiE4up-lKo_V-nBy-tAIxkIPQxY5qDhKCeHw,2445
+yaml/loader.py,sha256=UVa-zIqmkFSCIYq_PgSGm4NSJttHY2Rf_zQ4_b1fHN0,2061
+yaml/nodes.py,sha256=gPKNj8pKCdh2d4gr3gIYINnPOaOxGhJAUiYhGRnPE84,1440
+yaml/parser.py,sha256=ilWp5vvgoHFGzvOZDItFoGjD6D42nhlZrZyjAwa0oJo,25495
+yaml/reader.py,sha256=0dmzirOiDG4Xo41RnuQS7K9rkY3xjHiVasfDMNTqCNw,6794
+yaml/representer.py,sha256=IuWP-cAW9sHKEnS0gCqSa894k1Bg4cgTxaDwIcbRQ-Y,14190
+yaml/resolver.py,sha256=9L-VYfm4mWHxUD1Vg4X7rjDRK_7VZd6b92wzq7Y2IKY,9004
+yaml/scanner.py,sha256=YEM3iLZSaQwXcQRg2l2R4MdT0zGP2F9eHkKGKnHyWQY,51279
+yaml/serializer.py,sha256=ChuFgmhU01hj4xgI8GaKv6vfM2Bujwa9i7d2FAHj7cA,4165
+yaml/tokens.py,sha256=lTQIzSVw8Mg9wv459-TjiOQe6wVziqaRlqX2_89rp54,2573

hf_env/Lib/site-packages/PyYAML-6.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.44.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-win_amd64
+

hf_env/Lib/site-packages/PyYAML-6.0.2.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_yaml
+yaml

hf_env/Lib/site-packages/_yaml/__init__.py

@@ -0,0 +1,33 @@
+# This is a stub package designed to roughly emulate the _yaml
+# extension module, which previously existed as a standalone module
+# and has been moved into the `yaml` package namespace.
+# It does not perfectly mimic its old counterpart, but should get
+# close enough for anyone who's relying on it even when they shouldn't.
+import yaml
+
+# in some circumstances, the yaml module we imoprted may be from a different version, so we need
+# to tread carefully when poking at it here (it may not have the attributes we expect)
+if not getattr(yaml, '__with_libyaml__', False):
+    from sys import version_info
+
+    exc = ModuleNotFoundError if version_info >= (3, 6) else ImportError
+    raise exc("No module named '_yaml'")
+else:
+    from yaml._yaml import *
+    import warnings
+    warnings.warn(
+        'The _yaml extension module is now located at yaml._yaml'
+        ' and its location is subject to change.  To use the'
+        ' LibYAML-based parser and emitter, import from `yaml`:'
+        ' `from yaml import CLoader as Loader, CDumper as Dumper`.',
+        DeprecationWarning
+    )
+    del warnings
+    # Don't `del yaml` here because yaml is actually an existing
+    # namespace member of _yaml.
+
+__name__ = '_yaml'
+# If the module is top-level (i.e. not a part of any specific package)
+# then the attribute should be set to ''.
+# https://docs.python.org/3.8/library/types.html
+__package__ = ''

hf_env/Lib/site-packages/certifi-2025.1.31.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip