Upload 8 files (#4)

- Upload 8 files (8f2f8d57a7c03dfd989cf73060b9266a7e967321)


Co-authored-by: hardik kandpal <hardik8588@users.noreply.huggingface.co>

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libffi-dev \
+    git \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create necessary directories
+RUN mkdir -p static uploads temp data models_cache
+
+# Copy only the necessary files
+COPY app.py .
+COPY auth.py .
+COPY paypal_integration.py .
+COPY .env .
+
+# Set environment variables
+ENV LOAD_MODELS=True
+ENV MODELS_CACHE_DIR=/app/models_cache
+ENV PORT=7860
+ENV HOST=0.0.0.0
+
+# Expose the port
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,40 @@
----
-title: Testing
-emoji: 📚
-colorFrom: gray
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Legal Document Analysis API
+emoji: 📄
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: false
+license: mit
+---
+
+# Legal Document Analysis API
+
+This API provides tools for analyzing legal documents, videos, and audio files. It uses NLP models to extract insights, summarize content, and answer legal questions.
+
+## Features
+
+- Document analysis (PDF)
+- Video and audio transcription and analysis
+- Legal question answering
+- Risk assessment and visualization
+- Contract clause analysis
+
+## Deployment
+
+This API is deployed on Hugging Face Spaces.
+
+## API Endpoints
+
+- `/analyze_document` - Analyze legal documents
+- `/analyze_legal_video` - Analyze legal videos
+- `/analyze_legal_audio` - Analyze legal audio
+- `/ask_legal_question` - Ask questions about legal documents
+
+## Technologies
+
+- FastAPI
+- Hugging Face Transformers
+- SpaCy
+- PyTorch
+- MoviePy

auth.py

@@ -0,0 +1,633 @@
+import sqlite3
+import uuid
+import os
+import logging
+from datetime import datetime, timedelta
+import hashlib  # Use hashlib instead of jwt
+from passlib.hash import bcrypt
+from dotenv import load_dotenv
+from fastapi import Depends, HTTPException
+from fastapi.security import OAuth2PasswordBearer
+from pydantic import BaseModel
+from typing import Optional
+from fastapi import HTTPException, status
+import jwt
+from jwt.exceptions import PyJWTError
+import sqlite3
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('auth')
+
+# Security configuration
+SECRET_KEY = os.getenv("JWT_SECRET", "your-secret-key-for-development-only")
+ALGORITHM = "HS256" 
+JWT_EXPIRATION_DELTA = timedelta(days=1)  # Token valid for 1 day
+# Database path from environment variable or default
+# Fix the incorrect DB_PATH
+DB_PATH = os.getenv("DB_PATH", os.path.join(os.path.dirname(__file__), "data/user_data.db"))
+
+# FastAPI OAuth2 scheme
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+# Pydantic models for FastAPI
+class User(BaseModel):
+    id: str
+    email: str
+    subscription_tier: str = "free_tier"
+    subscription_expiry: Optional[datetime] = None
+    api_calls_remaining: int = 5
+    last_reset_date: Optional[datetime] = None
+
+class UserCreate(BaseModel):
+    email: str
+    password: str
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenData(BaseModel):
+    user_id: Optional[str] = None
+
+# Subscription tiers and limits
+# Update the SUBSCRIPTION_TIERS dictionary
+SUBSCRIPTION_TIERS = {
+    "free_tier": {
+        "price": 0,
+        "currency": "INR",
+        "features": ["basic_document_analysis", "basic_risk_assessment"],
+        "limits": {
+            "document_size_mb": 5,
+            "documents_per_month": 3,
+            "video_size_mb": 0,
+            "audio_size_mb": 0
+        }
+    },
+    "standard_tier": {
+        "price": 799,
+        "currency": "INR",
+        "features": ["basic_document_analysis", "basic_risk_assessment", "video_analysis", "audio_analysis", "chatbot"],
+        "limits": {
+            "document_size_mb": 20,
+            "documents_per_month": 20,
+            "video_size_mb": 100,
+            "audio_size_mb": 50
+        }
+    },
+    "premium_tier": {
+        "price": 1499,
+        "currency": "INR",
+        "features": ["basic_document_analysis", "basic_risk_assessment", "video_analysis", "audio_analysis", "chatbot", "detailed_risk_assessment", "contract_clause_analysis"],
+        "limits": {
+            "document_size_mb": 50,
+            "documents_per_month": 999999,  # Unlimited
+            "video_size_mb": 500,
+            "audio_size_mb": 200
+        }
+    }
+}
+
+# Database connection management
+def get_db_connection():
+    """Create and return a database connection with proper error handling"""
+    try:
+        # Ensure the directory exists
+        db_dir = os.path.dirname(DB_PATH)
+        os.makedirs(db_dir, exist_ok=True)
+        
+        conn = sqlite3.connect(DB_PATH)
+        conn.row_factory = sqlite3.Row  # Return rows as dictionaries
+        return conn
+    except sqlite3.Error as e:
+        logger.error(f"Database connection error: {e}")
+        raise Exception(f"Database connection failed: {e}")
+
+# Database setup
+# In the init_auth_db function, update the CREATE TABLE statement to match our schema
+def init_auth_db():
+    """Initialize the authentication database with required tables"""
+    try:
+        conn = get_db_connection()
+        c = conn.cursor()
+        
+        # Create users table with the correct schema
+        c.execute('''
+        CREATE TABLE IF NOT EXISTS users (
+            id TEXT PRIMARY KEY,
+            email TEXT UNIQUE NOT NULL,
+            hashed_password TEXT NOT NULL,
+            password TEXT,
+            subscription_tier TEXT DEFAULT 'free_tier',
+            is_active BOOLEAN DEFAULT 1,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            api_calls_remaining INTEGER DEFAULT 10,
+            last_reset_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        ''')
+        
+        # Create subscriptions table
+        c.execute('''
+        CREATE TABLE IF NOT EXISTS subscriptions (
+            id TEXT PRIMARY KEY,
+            user_id TEXT,
+            tier TEXT,
+            plan_id TEXT,
+            status TEXT,
+            created_at TIMESTAMP,
+            expires_at TIMESTAMP,
+            paypal_subscription_id TEXT,
+            FOREIGN KEY (user_id) REFERENCES users (id)
+        )
+        ''')
+        
+        # Create usage stats table
+        c.execute('''
+        CREATE TABLE IF NOT EXISTS usage_stats (
+            id TEXT PRIMARY KEY,
+            user_id TEXT,
+            month INTEGER,
+            year INTEGER,
+            analyses_used INTEGER,
+            FOREIGN KEY (user_id) REFERENCES users (id)
+        )
+        ''')
+        
+        # Create tokens table for refresh tokens
+        c.execute('''
+        CREATE TABLE IF NOT EXISTS refresh_tokens (
+            user_id TEXT,
+            token TEXT,
+            expires_at TIMESTAMP,
+            FOREIGN KEY (user_id) REFERENCES users (id)
+        )
+        ''')
+        
+        conn.commit()
+        logger.info("Database initialized successfully")
+    except Exception as e:
+        logger.error(f"Database initialization error: {e}")
+        raise
+    finally:
+        if conn:
+            conn.close()
+
+# Initialize the database
+init_auth_db()
+
+# Password hashing with bcrypt
+# Update the password hashing and verification functions to use a more reliable method
+
+# Replace these functions
+# Remove these conflicting functions
+# def hash_password(password):
+#     """Hash a password using bcrypt"""
+#     return bcrypt.hash(password)
+# 
+# def verify_password(plain_password, hashed_password):
+#     """Verify a password against its hash"""
+#     return bcrypt.verify(plain_password, hashed_password)
+
+# Keep only these improved functions
+def hash_password(password):
+    """Hash a password using bcrypt"""
+    # Use a more direct approach to avoid bcrypt version issues
+    import bcrypt
+    # Convert password to bytes if it's not already
+    if isinstance(password, str):
+        password = password.encode('utf-8')
+    # Generate salt and hash
+    salt = bcrypt.gensalt()
+    hashed = bcrypt.hashpw(password, salt)
+    # Return as string for storage
+    return hashed.decode('utf-8')
+
+def verify_password(plain_password, hashed_password):
+    """Verify a password against its hash"""
+    import bcrypt
+    # Convert inputs to bytes if they're not already
+    if isinstance(plain_password, str):
+        plain_password = plain_password.encode('utf-8')
+    if isinstance(hashed_password, str):
+        hashed_password = hashed_password.encode('utf-8')
+    
+    try:
+        # Use direct bcrypt verification
+        return bcrypt.checkpw(plain_password, hashed_password)
+    except Exception as e:
+        logger.error(f"Password verification error: {e}")
+        return False
+
+# User registration
+def register_user(email, password):
+    try:
+        conn = get_db_connection()
+        c = conn.cursor()
+        
+        # Check if user already exists
+        c.execute("SELECT * FROM users WHERE email = ?", (email,))
+        if c.fetchone():
+            return False, "Email already registered"
+        
+        # Create new user
+        user_id = str(uuid.uuid4())
+        
+        # Add more detailed logging
+        logger.info(f"Registering new user with email: {email}")
+        hashed_pw = hash_password(password)
+        logger.info(f"Password hashed successfully: {bool(hashed_pw)}")
+        
+        c.execute("""
+            INSERT INTO users 
+            (id, email, hashed_password, subscription_tier, api_calls_remaining, last_reset_date) 
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (user_id, email, hashed_pw, "free_tier", 5, datetime.now()))
+        
+        conn.commit()
+        logger.info(f"User registered successfully: {email}")
+        
+        # Verify the user was actually stored
+        c.execute("SELECT * FROM users WHERE email = ?", (email,))
+        stored_user = c.fetchone()
+        logger.info(f"User verification after registration: {bool(stored_user)}")
+        
+        access_token = create_access_token(user_id)
+        return True, {
+            "user_id": user_id,
+            "access_token": access_token,
+            "token_type": "bearer"
+        }
+    except Exception as e:
+        logger.error(f"User registration error: {e}")
+        return False, f"Registration failed: {str(e)}"
+    finally:
+        if conn:
+            conn.close()
+
+# User login
+# Fix the authenticate_user function
+# In the authenticate_user function, update the password verification to use hashed_password
+def authenticate_user(email, password):
+    """Authenticate a user and return user data with tokens"""
+    try:
+        conn = get_db_connection()
+        c = conn.cursor()
+        
+        # Get user by email
+        c.execute("SELECT * FROM users WHERE email = ? AND is_active = 1", (email,))
+        user = c.fetchone()
+        
+        if not user:
+            logger.warning(f"User not found: {email}")
+            return None
+            
+        # Add debug logging for password verification
+        logger.info(f"Verifying password for user: {email}")
+        logger.info(f"Stored hashed password: {user['hashed_password'][:20]}...")
+        
+        try:
+            # Check if password verification works
+            is_valid = verify_password(password, user['hashed_password'])
+            logger.info(f"Password verification result: {is_valid}")
+            
+            if not is_valid:
+                logger.warning(f"Password verification failed for user: {email}")
+                return None
+        except Exception as e:
+            logger.error(f"Password verification error: {e}")
+            return None
+        
+        # Update last login time if column exists
+        try:
+            c.execute("UPDATE users SET last_login = ? WHERE id = ?", 
+                    (datetime.now(), user['id']))
+            conn.commit()
+        except sqlite3.OperationalError:
+            # last_login column might not exist
+            pass
+        
+        # Convert sqlite3.Row to dict to use get() method
+        user_dict = dict(user)
+        
+        # Create and return a User object
+        return User(
+            id=user_dict['id'],
+            email=user_dict['email'],
+            subscription_tier=user_dict.get('subscription_tier', 'free_tier'),
+            subscription_expiry=None,  # Handle this properly if needed
+            api_calls_remaining=user_dict.get('api_calls_remaining', 5),
+            last_reset_date=user_dict.get('last_reset_date')
+        )
+    except Exception as e:
+        logger.error(f"Login error: {e}")
+        return None
+    finally:
+        if conn:
+            conn.close()
+
+# Token generation and validation - completely replaced
+def create_access_token(user_id):
+    """Create a new access token for a user"""
+    try:
+        # Create a JWT token with user_id and expiration
+        expiration = datetime.now() + JWT_EXPIRATION_DELTA
+        
+        # Create a token payload
+        payload = {
+            "sub": user_id,
+            "exp": expiration.timestamp()
+        }
+        
+        # Generate the JWT token
+        token = jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)
+        
+        logger.info(f"Created access token for user: {user_id}")
+        return token
+    except Exception as e:
+        logger.error(f"Token creation error: {e}")
+        return None
+
+
+def update_auth_db_schema():
+    """Update the authentication database schema with any missing columns"""
+    try:
+        conn = get_db_connection()
+        c = conn.cursor()
+        
+        # Check if tier column exists in subscriptions table
+        c.execute("PRAGMA table_info(subscriptions)")
+        columns = [column[1] for column in c.fetchall()]
+        
+        # Add tier column if it doesn't exist
+        if "tier" not in columns:
+            logger.info("Adding 'tier' column to subscriptions table")
+            c.execute("ALTER TABLE subscriptions ADD COLUMN tier TEXT")
+            conn.commit()
+            logger.info("Database schema updated successfully")
+        
+        conn.close()
+    except Exception as e:
+        logger.error(f"Database schema update error: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Database schema update error: {str(e)}"
+        )
+
+# Add this to your get_current_user function
+async def get_current_user(token: str = Depends(oauth2_scheme)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        # Decode the JWT token
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            logger.error("Token missing 'sub' field")
+            raise credentials_exception
+    except Exception as e:
+        logger.error(f"Token validation error: {str(e)}")
+        raise credentials_exception
+    
+    # Get user from database
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("SELECT id, email, subscription_tier, is_active FROM users WHERE id = ?", (user_id,))
+    user_data = cursor.fetchone()
+    conn.close()
+    
+    if user_data is None:
+        logger.error(f"User not found: {user_id}")
+        raise credentials_exception
+    
+    user = User(
+        id=user_data[0],
+        email=user_data[1],
+        subscription_tier=user_data[2],
+        is_active=bool(user_data[3])
+    )
+    
+    return user
+
+async def get_current_active_user(current_user: User = Depends(get_current_user)):
+    """Get the current active user"""
+    return current_user
+    
+def create_user_subscription(email, tier):
+    """Create a subscription for a user"""
+    try:
+        # Get user by email
+        conn = get_db_connection()
+        c = conn.cursor()
+        
+        # Get user ID
+        c.execute("SELECT id FROM users WHERE email = ?", (email,))
+        user_data = c.fetchone()
+        
+        if not user_data:
+            return False, "User not found"
+        
+        user_id = user_data['id']
+        
+        # Check if tier is valid
+        valid_tiers = ["standard_tier", "premium_tier"]
+        if tier not in valid_tiers:
+            return False, f"Invalid tier: {tier}. Must be one of {valid_tiers}"
+        
+        # Create subscription
+        subscription_id = str(uuid.uuid4())
+        created_at = datetime.now()
+        expires_at = created_at + timedelta(days=30)  # 30-day subscription
+        
+        # Insert subscription
+        c.execute("""
+            INSERT INTO subscriptions 
+            (id, user_id, tier, status, created_at, expires_at) 
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (subscription_id, user_id, tier, "active", created_at, expires_at))
+        
+        # Update user's subscription tier
+        c.execute("""
+            UPDATE users 
+            SET subscription_tier = ? 
+            WHERE id = ?
+        """, (tier, user_id))
+        
+        conn.commit()
+        
+        return True, {
+            "id": subscription_id,
+            "user_id": user_id,
+            "tier": tier,
+            "status": "active",
+            "created_at": created_at.isoformat(),
+            "expires_at": expires_at.isoformat()
+        }
+    except Exception as e:
+        logger.error(f"Subscription creation error: {e}")
+        return False, f"Failed to create subscription: {str(e)}"
+    finally:
+        if conn:
+            conn.close()
+
+def get_user(user_id: str):
+    """Get user by ID"""
+    try:
+        conn = get_db_connection()
+        c = conn.cursor()
+        
+        # Get user
+        c.execute("SELECT * FROM users WHERE id = ? AND is_active = 1", (user_id,))
+        user_data = c.fetchone()
+        
+        if not user_data:
+            return None
+            
+        # Convert to User model
+        user_dict = dict(user_data)
+        
+        # Handle datetime conversions if needed
+        if user_dict.get("subscription_expiry") and isinstance(user_dict["subscription_expiry"], str):
+            user_dict["subscription_expiry"] = datetime.fromisoformat(user_dict["subscription_expiry"])
+        if user_dict.get("last_reset_date") and isinstance(user_dict["last_reset_date"], str):
+            user_dict["last_reset_date"] = datetime.fromisoformat(user_dict["last_reset_date"])
+            
+        return User(
+            id=user_dict['id'],
+            email=user_dict['email'],
+            subscription_tier=user_dict['subscription_tier'],
+            subscription_expiry=user_dict.get('subscription_expiry'),
+            api_calls_remaining=user_dict.get('api_calls_remaining', 5),
+            last_reset_date=user_dict.get('last_reset_date')
+        )
+    except Exception as e:
+        logger.error(f"Get user error: {e}")
+        return None
+    finally:
+        if conn:
+            conn.close()
+
+def check_subscription_access(user: User, feature: str, file_size_mb: Optional[float] = None):
+    """Check if the user has access to the requested feature and file size"""
+    # Check if subscription is expired
+    if user.subscription_tier != "free_tier" and user.subscription_expiry and user.subscription_expiry < datetime.now():
+        # Downgrade to free tier if subscription expired
+        user.subscription_tier = "free_tier"
+        user.api_calls_remaining = SUBSCRIPTION_TIERS["free_tier"]["daily_api_calls"]
+        with get_db_connection() as conn:
+            c = conn.cursor()
+            c.execute("""
+                UPDATE users 
+                SET subscription_tier = ?, api_calls_remaining = ? 
+                WHERE id = ?
+            """, (user.subscription_tier, user.api_calls_remaining, user.id))
+            conn.commit()
+        
+    # Reset API calls if needed
+    user = reset_api_calls_if_needed(user)
+    
+    # Check if user has API calls remaining
+    if user.api_calls_remaining <= 0:
+        raise HTTPException(
+            status_code=429,
+            detail="API call limit reached for today. Please upgrade your subscription or try again tomorrow."
+        )
+    
+    # Check if feature is available in user's subscription tier
+    tier_features = SUBSCRIPTION_TIERS[user.subscription_tier]["features"]
+    if feature not in tier_features:
+        raise HTTPException(
+            status_code=403,
+            detail=f"The {feature} feature is not available in your {user.subscription_tier} subscription. Please upgrade to access this feature."
+        )
+    
+    # Check file size limit if applicable
+    if file_size_mb:
+        max_size = SUBSCRIPTION_TIERS[user.subscription_tier]["max_document_size_mb"]
+        if file_size_mb > max_size:
+            raise HTTPException(
+                status_code=413,
+                detail=f"File size exceeds the {max_size}MB limit for your {user.subscription_tier} subscription. Please upgrade or use a smaller file."
+            )
+    
+    # Decrement API calls remaining
+    user.api_calls_remaining -= 1
+    with get_db_connection() as conn:
+        c = conn.cursor()
+        c.execute("""
+            UPDATE users 
+            SET api_calls_remaining = ? 
+            WHERE id = ?
+        """, (user.api_calls_remaining, user.id))
+        conn.commit()
+    
+    return True
+
+def reset_api_calls_if_needed(user: User):
+    """Reset API call counter if it's a new day"""
+    today = datetime.now().date()
+    if user.last_reset_date is None or user.last_reset_date.date() < today:
+        tier_limits = SUBSCRIPTION_TIERS[user.subscription_tier]
+        user.api_calls_remaining = tier_limits["daily_api_calls"]
+        user.last_reset_date = datetime.now()
+        # Update the user in the database
+        with get_db_connection() as conn:
+            c = conn.cursor()
+            c.execute("""
+                UPDATE users 
+                SET api_calls_remaining = ?, last_reset_date = ? 
+                WHERE id = ?
+            """, (user.api_calls_remaining, user.last_reset_date, user.id))
+            conn.commit()
+            
+    return user
+
+def login_user(email, password):
+    """Login a user with email and password"""
+    try:
+        # Authenticate user
+        user = authenticate_user(email, password)
+        if not user:
+            return False, "Incorrect username or password"
+        
+        # Create access token
+        access_token = create_access_token(user.id)
+        
+        # Create refresh token
+        refresh_token = str(uuid.uuid4())
+        expires_at = datetime.now() + timedelta(days=30)
+        
+        # Store refresh token
+        conn = get_db_connection()
+        c = conn.cursor()
+        c.execute("INSERT INTO refresh_tokens VALUES (?, ?, ?)",
+                 (user.id, refresh_token, expires_at))
+        conn.commit()
+        
+        # Get subscription info
+        c.execute("SELECT * FROM subscriptions WHERE user_id = ? AND status = 'active'", (user.id,))
+        subscription = c.fetchone()
+        
+        # Convert subscription to dict if it exists, otherwise set to None
+        subscription_dict = dict(subscription) if subscription else None
+        
+        conn.close()
+        
+        return True, {
+            "user_id": user.id,
+            "email": user.email,
+            "access_token": access_token,
+            "refresh_token": refresh_token,
+            "subscription": subscription_dict
+        }
+    except Exception as e:
+        logger.error(f"Login error: {e}")
+        return False, f"Login failed: {str(e)}"

check_routes.py

@@ -0,0 +1,61 @@
+import os
+import sys
+import importlib.util
+
+def check_fastapi_routes():
+    """Check the FastAPI routes in the app.py file."""
+    print("Checking FastAPI routes...")
+    
+    # Store current directory
+    current_dir = os.getcwd()
+    
+    try:
+        # Change to the backend directory
+        os.chdir("doc-vid-analyze-main")
+        print(f"Current directory: {os.getcwd()}")
+        
+        # Check if app.py exists
+        if not os.path.exists("app.py"):
+            print(f"❌ Error: app.py not found in {os.getcwd()}")
+            return False
+        
+        # Load the app.py module
+        print("Loading app.py module...")
+        spec = importlib.util.spec_from_file_location("app", "app.py")
+        app_module = importlib.util.module_from_spec(spec)
+        sys.modules["app"] = app_module
+        spec.loader.exec_module(app_module)
+        
+        # Check if app is defined
+        if not hasattr(app_module, "app"):
+            print("❌ Error: 'app' object not found in app.py")
+            return False
+        
+        app = app_module.app
+        
+        # Print app information
+        print("\n📋 FastAPI App Information:")
+        print(f"App title: {app.title}")
+        print(f"App version: {app.version}")
+        print(f"App description: {app.description}")
+        
+        # Print routes
+        print("\n📋 FastAPI Routes:")
+        for route in app.routes:
+            print(f"Route: {route.path}")
+            print(f"  Methods: {route.methods}")
+            print(f"  Name: {route.name}")
+            print(f"  Endpoint: {route.endpoint.__name__ if hasattr(route.endpoint, '__name__') else route.endpoint}")
+            print()
+        
+        return True
+            
+    except Exception as e:
+        print(f"❌ Error checking routes: {e}")
+        return False
+    finally:
+        # Return to original directory
+        os.chdir(current_dir)
+
+if __name__ == "__main__":
+    check_fastapi_routes()

fix_users_table.py

@@ -0,0 +1,180 @@
+import sqlite3
+import os
+import uuid
+import datetime
+
+# Define both database paths
+DB_PATH_1 = os.path.join(os.path.dirname(__file__), "../data/user_data.db")
+DB_PATH_2 = os.path.join(os.path.dirname(__file__), "data/user_data.db")
+
+# Define the function to create users table
+# Make sure the create_users_table function allows NULL for hashed_password temporarily
+def create_users_table(cursor):
+    """Create the users table with all required columns"""
+    cursor.execute('''
+    CREATE TABLE users (
+        id TEXT PRIMARY KEY,
+        email TEXT UNIQUE NOT NULL,
+        hashed_password TEXT DEFAULT 'temp_hash_for_migration',
+        password TEXT,
+        subscription_tier TEXT DEFAULT 'free',
+        is_active BOOLEAN DEFAULT 1,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        api_calls_remaining INTEGER DEFAULT 10,
+        last_reset_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )
+    ''')
+
+# Update the CREATE TABLE statement to include all necessary columns
+def fix_users_table(db_path):
+    # Make sure the data directory exists
+    data_dir = os.path.dirname(db_path)
+    if not os.path.exists(data_dir):
+        print(f"Creating data directory: {data_dir}")
+        os.makedirs(data_dir, exist_ok=True)
+    
+    if not os.path.exists(db_path):
+        print(f"Database does not exist at: {os.path.abspath(db_path)}")
+        return False
+    
+    print(f"Using database path: {os.path.abspath(db_path)}")
+    
+    # Connect to the database
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    
+    # Check if users table exists
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='users'")
+    if cursor.fetchone():
+        print("Users table exists, checking schema...")
+        
+        # Check columns
+        cursor.execute("PRAGMA table_info(users)")
+        columns_info = cursor.fetchall()
+        columns = [column[1] for column in columns_info]
+        
+        # List of all required columns
+        required_columns = ['id', 'email', 'hashed_password', 'password', 'subscription_tier', 
+                           'is_active', 'created_at', 'api_calls_remaining', 'last_reset_date']
+        
+        # Check if any required column is missing
+        missing_columns = [col for col in required_columns if col not in columns]
+        
+        if missing_columns:
+            print(f"Schema needs fixing. Missing columns: {', '.join(missing_columns)}")
+            
+            # Dynamically build the SELECT query based on available columns
+            available_columns = [col for col in columns if col != 'id']  # Exclude id as we'll generate new ones
+            
+            if not available_columns:
+                print("No usable columns found in users table, creating new table...")
+                cursor.execute("DROP TABLE users")
+                create_users_table(cursor)
+                print("Created new empty users table with correct schema")
+            else:
+                # Backup existing users with available columns
+                select_query = f"SELECT {', '.join(available_columns)} FROM users"
+                print(f"Backing up users with query: {select_query}")
+                cursor.execute(select_query)
+                existing_users = cursor.fetchall()
+                
+                # Drop the existing table
+                cursor.execute("DROP TABLE users")
+                
+                # Create the table with the correct schema
+                create_users_table(cursor)
+                
+                # Restore the users with new UUIDs for IDs
+                if existing_users:
+                    current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                    for user in existing_users:
+                        user_id = str(uuid.uuid4())
+                        
+                        # Create a dictionary to map column names to values
+                        user_data = {'id': user_id}
+                        for i, col in enumerate(available_columns):
+                            user_data[col] = user[i]
+                        
+                        # Set default values for missing columns
+                        # Add a default value for hashed_password in the Set default values section
+                        if 'hashed_password' not in user_data:
+                            user_data['hashed_password'] = 'temp_hash_for_migration'  # Temporary hash for migration
+                        if 'subscription_tier' not in user_data:
+                            user_data['subscription_tier'] = 'free'
+                        if 'is_active' not in user_data:
+                            user_data['is_active'] = 1
+                        if 'created_at' not in user_data:
+                            user_data['created_at'] = current_time
+                        if 'api_calls_remaining' not in user_data:
+                            user_data['api_calls_remaining'] = 10
+                        if 'last_reset_date' not in user_data:
+                            user_data['last_reset_date'] = current_time
+                        
+                        # Build INSERT query with all required columns
+                        insert_columns = ['id']
+                        insert_values = [user_id]
+                        
+                        # Add values for columns that exist in the old table
+                        for col in available_columns:
+                            insert_columns.append(col)
+                            insert_values.append(user_data[col])
+                        
+                        # Add default values for columns that don't exist in the old table
+                        for col in required_columns:
+                            # Add hashed_password to the column default values section
+                            if col not in ['id'] + available_columns:
+                                insert_columns.append(col)
+                                if col == 'subscription_tier':
+                                    insert_values.append('free')
+                                elif col == 'is_active':
+                                    insert_values.append(1)
+                                elif col == 'created_at':
+                                    insert_values.append(current_time)
+                                elif col == 'api_calls_remaining':
+                                    insert_values.append(10)
+                                elif col == 'last_reset_date':
+                                    insert_values.append(current_time)
+                                elif col == 'hashed_password':
+                                    insert_values.append('temp_hash_for_migration')  # Temporary hash for migration
+                                else:
+                                    insert_values.append(None)  # Default to NULL for other columns
+                        
+                        placeholders = ', '.join(['?'] * len(insert_columns))
+                        insert_query = f"INSERT INTO users ({', '.join(insert_columns)}) VALUES ({placeholders})"
+                        
+                        cursor.execute(insert_query, insert_values)
+                
+                print(f"Fixed users table, restored {len(existing_users)} users")
+        else:
+            print("Users table schema is correct")
+    else:
+        print("Users table doesn't exist, creating it now...")
+        create_users_table(cursor)
+        print("Users table created successfully")
+    
+    # Commit changes and close connection
+    conn.commit()
+    conn.close()
+    return True
+
+if __name__ == "__main__":
+    print("Checking first database location...")
+    success1 = fix_users_table(DB_PATH_1)
+    
+    print("\nChecking second database location...")
+    success2 = fix_users_table(DB_PATH_2)
+    
+    if not (success1 or success2):
+        print("\nWarning: Could not find any existing database files.")
+        print("Creating a new database at the primary location...")
+        # Create a new database at the primary location
+        data_dir = os.path.dirname(DB_PATH_1)
+        if not os.path.exists(data_dir):
+            os.makedirs(data_dir, exist_ok=True)
+        
+        conn = sqlite3.connect(DB_PATH_1)
+        cursor = conn.cursor()
+        create_users_table(cursor)
+        conn.commit()
+        conn.close()
+        print(f"Created new database at: {os.path.abspath(DB_PATH_1)}")

initialize_plans.py

@@ -0,0 +1,25 @@
+import os
+import sys
+from dotenv import load_dotenv
+from paypal_integration import initialize_subscription_plans
+
+# Load environment variables
+load_dotenv()
+
+def main():
+    """Initialize PayPal subscription plans"""
+    print("Initializing PayPal subscription plans...")
+    plans = initialize_subscription_plans()
+    
+    if plans:
+        print("✅ Plans initialized successfully:")
+        for tier, plan_id in plans.items():
+            print(f"  - {tier}: {plan_id}")
+        return True
+    else:
+        print("❌ Failed to initialize plans. Check the logs for details.")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

paypal_integration.py

@@ -0,0 +1,1004 @@
+import requests
+import json
+import sqlite3
+from datetime import datetime, timedelta
+import uuid
+import os
+import logging
+from requests.adapters import HTTPAdapter
+from requests.packages.urllib3.util.retry import Retry
+from auth import get_db_connection
+from dotenv import load_dotenv
+
+# PayPal API Configuration - Remove default values for production
+PAYPAL_CLIENT_ID = os.getenv("PAYPAL_CLIENT_ID")
+PAYPAL_SECRET = os.getenv("PAYPAL_SECRET")
+PAYPAL_BASE_URL = os.getenv("PAYPAL_BASE_URL", "https://api-m.sandbox.paypal.com")
+
+# Add validation to ensure credentials are provided
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(os.path.join(os.path.dirname(__file__), "../logs/paypal.log")),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger("paypal_integration")
+
+# Then replace print statements with logger calls
+# For example:
+if not PAYPAL_CLIENT_ID or not PAYPAL_SECRET:
+    logger.warning("PayPal credentials not found in environment variables")
+
+
+# Get PayPal access token
+# Add better error handling for production
+# Create a session with retry capability
+def create_retry_session(retries=3, backoff_factor=0.3):
+    session = requests.Session()
+    retry = Retry(
+        total=retries,
+        read=retries,
+        connect=retries,
+        backoff_factor=backoff_factor,
+        status_forcelist=[500, 502, 503, 504],
+    )
+    adapter = HTTPAdapter(max_retries=retry)
+    session.mount('http://', adapter)
+    session.mount('https://', adapter)
+    return session
+
+# Then use this session for API calls
+# Replace get_access_token with logger instead of print
+def get_access_token():
+    url = f"{PAYPAL_BASE_URL}/v1/oauth2/token"
+    headers = {
+        "Accept": "application/json",
+        "Accept-Language": "en_US"
+    }
+    data = "grant_type=client_credentials"
+    
+    try:
+        session = create_retry_session()
+        response = session.post(
+            url, 
+            auth=(PAYPAL_CLIENT_ID, PAYPAL_SECRET),
+            headers=headers,
+            data=data
+        )
+        
+        if response.status_code == 200:
+            return response.json()["access_token"]
+        else:
+            logger.error(f"Error getting access token: {response.status_code}")
+            return None
+    except Exception as e:
+        logger.error(f"Exception in get_access_token: {str(e)}")
+        return None
+
+def call_paypal_api(endpoint, method="GET", data=None, token=None):
+    """
+    Helper function to make PayPal API calls
+    
+    Args:
+        endpoint: API endpoint (without base URL)
+        method: HTTP method (GET, POST, etc.)
+        data: Request payload (for POST/PUT)
+        token: PayPal access token (will be fetched if None)
+        
+    Returns:
+        tuple: (success, response_data or error_message)
+    """
+    try:
+        if not token:
+            token = get_access_token()
+            if not token:
+                return False, "Failed to get PayPal access token"
+        
+        url = f"{PAYPAL_BASE_URL}{endpoint}"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {token}"
+        }
+        
+        session = create_retry_session()
+        
+        if method.upper() == "GET":
+            response = session.get(url, headers=headers)
+        elif method.upper() == "POST":
+            response = session.post(url, headers=headers, data=json.dumps(data) if data else None)
+        elif method.upper() == "PUT":
+            response = session.put(url, headers=headers, data=json.dumps(data) if data else None)
+        else:
+            return False, f"Unsupported HTTP method: {method}"
+        
+        if response.status_code in [200, 201, 204]:
+            if response.status_code == 204:  # No content
+                return True, {}
+            return True, response.json() if response.text else {}
+        else:
+            logger.error(f"PayPal API error: {response.status_code} - {response.text}")
+            return False, f"PayPal API error: {response.status_code} - {response.text}"
+            
+    except Exception as e:
+        logger.error(f"Error calling PayPal API: {str(e)}")
+        return False, f"Error calling PayPal API: {str(e)}"
+
+def create_paypal_subscription(user_id, tier):
+    """Create a PayPal subscription for a user"""
+    try:
+        # Get the price from the subscription tier
+        from auth import SUBSCRIPTION_TIERS
+        
+        if tier not in SUBSCRIPTION_TIERS:
+            return False, f"Invalid tier: {tier}"
+        
+        price = SUBSCRIPTION_TIERS[tier]["price"]
+        currency = SUBSCRIPTION_TIERS[tier]["currency"]
+        
+        # Create a PayPal subscription (implement PayPal API calls here)
+        # For now, just return a success response
+        return True, {
+            "subscription_id": f"test_sub_{uuid.uuid4()}",
+            "status": "ACTIVE",
+            "tier": tier,
+            "price": price,
+            "currency": currency
+        }
+    except Exception as e:
+        logger.error(f"Error creating PayPal subscription: {str(e)}")
+        return False, f"Failed to create PayPal subscription: {str(e)}"
+
+        
+# Create a product in PayPal
+def create_product(name, description):
+    """Create a product in PayPal"""
+    payload = {
+        "name": name,
+        "description": description,
+        "type": "SERVICE",
+        "category": "SOFTWARE"
+    }
+    
+    success, result = call_paypal_api("/v1/catalogs/products", "POST", payload)
+    if success:
+        return result["id"]
+    else:
+        logger.error(f"Failed to create product: {result}")
+        return None
+
+# Create a subscription plan in PayPal
+# Update create_plan to use INR instead of USD
+def create_plan(product_id, name, price, interval="MONTH", interval_count=1):
+    """Create a subscription plan in PayPal"""
+    payload = {
+        "product_id": product_id,
+        "name": name,
+        "billing_cycles": [
+            {
+                "frequency": {
+                    "interval_unit": interval,
+                    "interval_count": interval_count
+                },
+                "tenure_type": "REGULAR",
+                "sequence": 1,
+                "total_cycles": 0,  # Infinite cycles
+                "pricing_scheme": {
+                    "fixed_price": {
+                        "value": str(price),
+                        "currency_code": "USD"
+                    }
+                }
+            }
+        ],
+        "payment_preferences": {
+            "auto_bill_outstanding": True,
+            "setup_fee": {
+                "value": "0",
+                "currency_code": "USD"
+            },
+            "setup_fee_failure_action": "CONTINUE",
+            "payment_failure_threshold": 3
+        }
+    }
+    
+    success, result = call_paypal_api("/v1/billing/plans", "POST", payload)
+    if success:
+        return result["id"]
+    else:
+        logger.error(f"Failed to create plan: {result}")
+        return None
+
+# Update initialize_subscription_plans to use INR pricing
+def initialize_subscription_plans():
+    """
+    Initialize PayPal subscription plans for the application.
+    This should be called once to set up the plans in PayPal.
+    """
+    try:
+        # Check if plans already exist
+        existing_plans = get_subscription_plans()
+        if existing_plans and len(existing_plans) >= 2:
+            logger.info("PayPal plans already initialized")
+            return existing_plans
+        
+        # First, create products for each tier
+        products = {
+            "standard_tier": {
+                "name": "Standard Legal Document Analysis",
+                "description": "Standard subscription with document analysis features",
+                "type": "SERVICE",
+                "category": "SOFTWARE"
+            },
+            "premium_tier": {
+                "name": "Premium Legal Document Analysis",
+                "description": "Premium subscription with all document analysis features",
+                "type": "SERVICE",
+                "category": "SOFTWARE"
+            }
+        }
+        
+        product_ids = {}
+        for tier, product_data in products.items():
+            success, result = call_paypal_api("/v1/catalogs/products", "POST", product_data)
+            if success:
+                product_ids[tier] = result["id"]
+                logger.info(f"Created PayPal product for {tier}: {result['id']}")
+            else:
+                logger.error(f"Failed to create product for {tier}: {result}")
+                return None
+        
+        # Define the plans with product IDs - Changed currency to USD
+        plans = {
+            "standard_tier": {
+                "product_id": product_ids["standard_tier"],
+                "name": "Standard Plan",
+                "description": "Standard subscription with basic features",
+                "billing_cycles": [
+                    {
+                        "frequency": {
+                            "interval_unit": "MONTH",
+                            "interval_count": 1
+                        },
+                        "tenure_type": "REGULAR",
+                        "sequence": 1,
+                        "total_cycles": 0,
+                        "pricing_scheme": {
+                            "fixed_price": {
+                                "value": "9.99",
+                                "currency_code": "USD"
+                            }
+                        }
+                    }
+                ],
+                "payment_preferences": {
+                    "auto_bill_outstanding": True,
+                    "setup_fee": {
+                        "value": "0",
+                        "currency_code": "USD"
+                    },
+                    "setup_fee_failure_action": "CONTINUE",
+                    "payment_failure_threshold": 3
+                }
+            },
+            "premium_tier": {
+                "product_id": product_ids["premium_tier"],
+                "name": "Premium Plan",
+                "description": "Premium subscription with all features",
+                "billing_cycles": [
+                    {
+                        "frequency": {
+                            "interval_unit": "MONTH",
+                            "interval_count": 1
+                        },
+                        "tenure_type": "REGULAR",
+                        "sequence": 1,
+                        "total_cycles": 0,
+                        "pricing_scheme": {
+                            "fixed_price": {
+                                "value": "19.99",
+                                "currency_code": "USD"
+                            }
+                        }
+                    }
+                ],
+                "payment_preferences": {
+                    "auto_bill_outstanding": True,
+                    "setup_fee": {
+                        "value": "0",
+                        "currency_code": "USD"
+                    },
+                    "setup_fee_failure_action": "CONTINUE",
+                    "payment_failure_threshold": 3
+                }
+            }
+        }
+        
+        # Create the plans in PayPal
+        created_plans = {}
+        for tier, plan_data in plans.items():
+            success, result = call_paypal_api("/v1/billing/plans", "POST", plan_data)
+            if success:
+                created_plans[tier] = result["id"]
+                logger.info(f"Created PayPal plan for {tier}: {result['id']}")
+            else:
+                logger.error(f"Failed to create plan for {tier}: {result}")
+        
+        # Save the plan IDs to a file
+        if created_plans:
+            save_subscription_plans(created_plans)
+            return created_plans
+        else:
+            logger.error("Failed to create any PayPal plans")
+            return None
+    except Exception as e:
+        logger.error(f"Error initializing subscription plans: {str(e)}")
+        return None
+
+# Update create_subscription_link to use call_paypal_api helper
+def create_subscription_link(plan_id):
+    # Get the plan IDs
+    plans = get_subscription_plans()
+    if not plans:
+        return None
+    
+    # Use environment variable for the app URL to make it work in different environments
+    app_url = os.getenv("APP_URL", "http://localhost:8501")
+    
+    payload = {
+        "plan_id": plans[plan_id],
+        "application_context": {
+            "brand_name": "Legal Document Analyzer",
+            "locale": "en_US",
+            "shipping_preference": "NO_SHIPPING",
+            "user_action": "SUBSCRIBE_NOW",
+            "return_url": f"{app_url}?status=success&subscription_id={{id}}",
+            "cancel_url": f"{app_url}?status=cancel"
+        }
+    }
+    
+    success, data = call_paypal_api("/v1/billing/subscriptions", "POST", payload)
+    if not success:
+        logger.error(f"Error creating subscription: {data}")
+        return None
+    
+    try:
+        return {
+            "subscription_id": data["id"],
+            "approval_url": next(link["href"] for link in data["links"] if link["rel"] == "approve")
+        }
+    except Exception as e:
+        logger.error(f"Exception processing subscription response: {str(e)}")
+        return None
+
+# Fix the webhook handler function signature to match how it's called in app.py
+def handle_subscription_webhook(payload):
+    """
+    Handle PayPal subscription webhooks
+    
+    Args:
+        payload: The full webhook payload
+        
+    Returns:
+        tuple: (success, result)
+            - success: True if successful, False otherwise
+            - result: Success message or error message
+    """
+    try:
+        event_type = payload.get("event_type")
+        resource = payload.get("resource", {})
+        
+        logger.info(f"Received PayPal webhook: {event_type}")
+        
+        # Handle different event types
+        if event_type == "BILLING.SUBSCRIPTION.CREATED":
+            # A subscription was created
+            subscription_id = resource.get("id")
+            if not subscription_id:
+                return False, "Missing subscription ID in webhook"
+                
+            # Update subscription status in database
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE subscriptions SET status = 'pending' WHERE paypal_subscription_id = ?",
+                (subscription_id,)
+            )
+            conn.commit()
+            conn.close()
+            
+            return True, "Subscription created successfully"
+            
+        elif event_type == "BILLING.SUBSCRIPTION.ACTIVATED":
+            # A subscription was activated
+            subscription_id = resource.get("id")
+            if not subscription_id:
+                return False, "Missing subscription ID in webhook"
+                
+            # Update subscription status in database
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE subscriptions SET status = 'active' WHERE paypal_subscription_id = ?",
+                (subscription_id,)
+            )
+            conn.commit()
+            conn.close()
+            
+            return True, "Subscription activated successfully"
+            
+        elif event_type == "BILLING.SUBSCRIPTION.CANCELLED":
+            # A subscription was cancelled
+            subscription_id = resource.get("id")
+            if not subscription_id:
+                return False, "Missing subscription ID in webhook"
+                
+            # Update subscription status in database
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE subscriptions SET status = 'cancelled' WHERE paypal_subscription_id = ?",
+                (subscription_id,)
+            )
+            conn.commit()
+            conn.close()
+            
+            return True, "Subscription cancelled successfully"
+            
+        elif event_type == "BILLING.SUBSCRIPTION.SUSPENDED":
+            # A subscription was suspended
+            subscription_id = resource.get("id")
+            if not subscription_id:
+                return False, "Missing subscription ID in webhook"
+                
+            # Update subscription status in database
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE subscriptions SET status = 'suspended' WHERE paypal_subscription_id = ?",
+                (subscription_id,)
+            )
+            conn.commit()
+            conn.close()
+            
+            return True, "Subscription suspended successfully"
+            
+        else:
+            # Unhandled event type
+            logger.info(f"Unhandled webhook event type: {event_type}")
+            return True, f"Unhandled event type: {event_type}"
+            
+    except Exception as e:
+        logger.error(f"Error handling webhook: {str(e)}")
+        return False, f"Error handling webhook: {str(e)}"
+# Add this function to update user subscription
+def update_user_subscription(user_email, subscription_id, tier):
+    """
+    Update a user's subscription status
+    
+    Args:
+        user_email: The email of the user
+        subscription_id: The PayPal subscription ID
+        tier: The subscription tier
+        
+    Returns:
+        tuple: (success, result)
+            - success: True if successful, False otherwise
+            - result: Success message or error message
+    """
+    try:
+        # Get user ID from email
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        cursor.execute("SELECT id FROM users WHERE email = ?", (user_email,))
+        user_result = cursor.fetchone()
+        
+        if not user_result:
+            conn.close()
+            return False, f"User not found: {user_email}"
+        
+        user_id = user_result[0]
+        
+        # Update the subscription status
+        cursor.execute(
+            "UPDATE subscriptions SET status = 'active' WHERE user_id = ? AND paypal_subscription_id = ?",
+            (user_id, subscription_id)
+        )
+        
+        # Deactivate any other active subscriptions for this user
+        cursor.execute(
+            "UPDATE subscriptions SET status = 'inactive' WHERE user_id = ? AND paypal_subscription_id != ? AND status = 'active'",
+            (user_id, subscription_id)
+        )
+        
+        # Update the user's subscription tier
+        cursor.execute(
+            "UPDATE users SET subscription_tier = ? WHERE email = ?",
+            (tier, user_email)
+        )
+        
+        conn.commit()
+        conn.close()
+        
+        return True, f"Subscription updated to {tier} tier"
+        
+    except Exception as e:
+        logger.error(f"Error updating user subscription: {str(e)}")
+        return False, f"Error updating subscription: {str(e)}"
+
+# Add this near the top with other path definitions
+# Update the PLAN_IDS_PATH definition to use the correct path
+PLAN_IDS_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "data", "plan_ids.json"))
+
+# Make sure the data directory exists
+os.makedirs(os.path.dirname(PLAN_IDS_PATH), exist_ok=True)
+
+# Add this debug log to see where the file is expected
+logger.info(f"PayPal plans will be stored at: {PLAN_IDS_PATH}")
+
+# Add this function if it's not defined elsewhere
+def get_db_connection():
+    """Get a connection to the SQLite database"""
+    DB_PATH = os.getenv("DB_PATH", os.path.join(os.path.dirname(__file__), "../data/user_data.db"))
+    # Make sure the data directory exists
+    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+    return sqlite3.connect(DB_PATH)
+
+# Add this function to create subscription tables if needed
+def initialize_database():
+    """Initialize the database tables needed for subscriptions"""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    
+    # Check if subscriptions table exists
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='subscriptions'")
+    if cursor.fetchone():
+        # Table exists, check if required columns exist
+        cursor.execute("PRAGMA table_info(subscriptions)")
+        columns = [column[1] for column in cursor.fetchall()]
+        
+        # Check for missing columns and add them if needed
+        if "user_id" not in columns:
+            logger.info("Adding 'user_id' column to subscriptions table")
+            cursor.execute("ALTER TABLE subscriptions ADD COLUMN user_id TEXT NOT NULL DEFAULT ''")
+        
+        if "created_at" not in columns:
+            logger.info("Adding 'created_at' column to subscriptions table")
+            cursor.execute("ALTER TABLE subscriptions ADD COLUMN created_at TIMESTAMP")
+        
+        if "expires_at" not in columns:
+            logger.info("Adding 'expires_at' column to subscriptions table")
+            cursor.execute("ALTER TABLE subscriptions ADD COLUMN expires_at TIMESTAMP")
+        
+        if "paypal_subscription_id" not in columns:
+            logger.info("Adding 'paypal_subscription_id' column to subscriptions table")
+            cursor.execute("ALTER TABLE subscriptions ADD COLUMN paypal_subscription_id TEXT")
+    else:
+        # Create subscriptions table with all required columns
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS subscriptions (
+            id TEXT PRIMARY KEY,
+            user_id TEXT NOT NULL,
+            tier TEXT NOT NULL,
+            status TEXT NOT NULL,
+            created_at TIMESTAMP NOT NULL,
+            expires_at TIMESTAMP,
+            paypal_subscription_id TEXT
+        )
+        ''')
+        logger.info("Created subscriptions table with all required columns")
+    
+    # Create PayPal plans table if it doesn't exist
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS paypal_plans (
+        plan_id TEXT PRIMARY KEY,
+        tier TEXT NOT NULL,
+        price REAL NOT NULL,
+        currency TEXT NOT NULL,
+        created_at TIMESTAMP NOT NULL
+    )
+    ''')
+    
+    conn.commit()
+    conn.close()
+    logger.info("Database initialization completed")
+
+
+def create_user_subscription_mock(user_email, tier):
+    """
+    Create a mock subscription for testing
+    
+    Args:
+        user_email: The email of the user
+        tier: The subscription tier
+        
+    Returns:
+        tuple: (success, result)
+    """
+    try:
+        logger.info(f"Creating mock subscription for {user_email} at tier {tier}")
+        
+        # Get user ID from email
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        cursor.execute("SELECT id FROM users WHERE email = ?", (user_email,))
+        user_result = cursor.fetchone()
+        
+        if not user_result:
+            conn.close()
+            return False, f"User not found: {user_email}"
+        
+        user_id = user_result[0]
+        
+        # Create a mock subscription ID
+        subscription_id = f"mock_sub_{uuid.uuid4()}"
+        
+        # Store the subscription in database
+        sub_id = str(uuid.uuid4())
+        start_date = datetime.now()
+        
+        cursor.execute(
+            "INSERT INTO subscriptions (id, user_id, tier, status, created_at, expires_at, paypal_subscription_id) VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (sub_id, user_id, tier, "active", start_date, start_date + timedelta(days=30), subscription_id)
+        )
+        
+        # Update user's subscription tier
+        cursor.execute(
+            "UPDATE users SET subscription_tier = ? WHERE id = ?",
+            (tier, user_id)
+        )
+        
+        conn.commit()
+        conn.close()
+        
+        # Use environment variable for the app URL
+        app_url = os.getenv("APP_URL", "http://localhost:3000")
+        
+        # Return success with mock approval URL that matches the real PayPal URL pattern
+        return True, {
+            "subscription_id": subscription_id,
+            "approval_url": f"{app_url}/subscription/callback?status=success&subscription_id={subscription_id}",
+            "tier": tier
+        }
+        
+    except Exception as e:
+        logger.error(f"Error creating mock subscription: {str(e)}")
+        return False, f"Error creating subscription: {str(e)}"
+
+# Add this at the end of the file
+def initialize():
+    """Initialize the PayPal integration module"""
+    try:
+        # Create necessary directories
+        os.makedirs(os.path.dirname(PLAN_IDS_PATH), exist_ok=True)
+        
+        # Initialize database
+        initialize_database()
+        
+        # Initialize subscription plans
+        plans = get_subscription_plans()
+        if plans:
+            logger.info(f"Subscription plans initialized: {plans}")
+        else:
+            logger.warning("Failed to initialize subscription plans")
+            
+        return True
+    except Exception as e:
+        logger.error(f"Error initializing PayPal integration: {str(e)}")
+        return False
+
+# Call initialize when the module is imported
+initialize()
+
+# Add this function to get subscription plans
+def get_subscription_plans():
+    """
+    Get all available subscription plans with correct pricing
+    """
+    try:
+        # Check if we have plan IDs saved in a file
+        if os.path.exists(PLAN_IDS_PATH):
+            try:
+                with open(PLAN_IDS_PATH, 'r') as f:
+                    plans = json.load(f)
+                    logger.info(f"Loaded subscription plans from {PLAN_IDS_PATH}: {plans}")
+                    return plans
+            except Exception as e:
+                logger.error(f"Error reading plan IDs file: {str(e)}")
+                return {}
+        
+        # If no file exists, return empty dict
+        logger.warning(f"No plan IDs file found at {PLAN_IDS_PATH}. Please initialize subscription plans.")
+        return {}
+        
+    except Exception as e:
+        logger.error(f"Error getting subscription plans: {str(e)}")
+        return {}
+
+# Add this function to create subscription tables if needed
+def initialize_database():
+    """Initialize the database tables needed for subscriptions"""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    
+    # Create subscriptions table if it doesn't exist
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS subscriptions (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        tier TEXT NOT NULL,
+        status TEXT NOT NULL,
+        created_at TIMESTAMP NOT NULL,
+        expires_at TIMESTAMP,
+        paypal_subscription_id TEXT
+    )
+    ''')
+    
+    # Create PayPal plans table if it doesn't exist
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS paypal_plans (
+        plan_id TEXT PRIMARY KEY,
+        tier TEXT NOT NULL,
+        price REAL NOT NULL,
+        currency TEXT NOT NULL,
+        created_at TIMESTAMP NOT NULL
+    )
+    ''')
+    
+    conn.commit()
+    conn.close()
+
+
+def create_user_subscription(user_email, tier):
+    """
+    Create a real PayPal subscription for a user
+    
+    Args:
+        user_email: The email of the user
+        tier: The subscription tier (standard_tier or premium_tier)
+    
+    Returns:
+        tuple: (success, result)
+            - success: True if successful, False otherwise
+            - result: Dictionary with subscription details or error message
+    """
+    try:
+        # Validate tier
+        valid_tiers = ["standard_tier", "premium_tier"]
+        if tier not in valid_tiers:
+            return False, f"Invalid tier: {tier}. Must be one of {valid_tiers}"
+        
+        # Get the plan IDs
+        plans = get_subscription_plans()
+        
+        # Log the plans for debugging
+        logger.info(f"Available subscription plans: {plans}")
+        
+        # If no plans found, check if the file exists and try to load it directly
+        if not plans:
+            if os.path.exists(PLAN_IDS_PATH):
+                logger.info(f"Plan IDs file exists at {PLAN_IDS_PATH}, but couldn't load plans. Trying direct load.")
+                try:
+                    with open(PLAN_IDS_PATH, 'r') as f:
+                        plans = json.load(f)
+                        logger.info(f"Directly loaded plans: {plans}")
+                except Exception as e:
+                    logger.error(f"Error directly loading plans: {str(e)}")
+            else:
+                logger.error(f"Plan IDs file does not exist at {PLAN_IDS_PATH}")
+                
+            # If still no plans, return error
+            if not plans:
+                logger.error("No PayPal plans found. Please initialize plans first.")
+                return False, "PayPal plans not configured. Please contact support."
+        
+        # Check if the tier exists in plans
+        if tier not in plans:
+            return False, f"No plan found for tier: {tier}"
+            
+        # Use environment variable for the app URL
+        app_url = os.getenv("APP_URL", "http://localhost:3000")
+        
+        # Create the subscription with PayPal
+        payload = {
+            "plan_id": plans[tier],
+            "subscriber": {
+                "email_address": user_email
+            },
+            "application_context": {
+                "brand_name": "Legal Document Analyzer",
+                "locale": "en-US",  # Changed from en_US to en-US
+                "shipping_preference": "NO_SHIPPING",
+                "user_action": "SUBSCRIBE_NOW",
+                "return_url": f"{app_url}/subscription/callback?status=success",
+                "cancel_url": f"{app_url}/subscription/callback?status=cancel"
+            }
+        }
+        
+        # Make the API call to PayPal
+        success, subscription_data = call_paypal_api("/v1/billing/subscriptions", "POST", payload)
+        if not success:
+            return False, subscription_data  # This is already an error message
+        
+        # Extract the approval URL
+        approval_url = next((link["href"] for link in subscription_data["links"] 
+                            if link["rel"] == "approve"), None)
+        
+        if not approval_url:
+            return False, "No approval URL found in PayPal response"
+        
+        # Get user ID from email
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        cursor.execute("SELECT id FROM users WHERE email = ?", (user_email,))
+        user_result = cursor.fetchone()
+        
+        if not user_result:
+            conn.close()
+            return False, f"User not found: {user_email}"
+        
+        user_id = user_result[0]
+        
+        # Store pending subscription in database
+        sub_id = str(uuid.uuid4())
+        start_date = datetime.now()
+        
+        cursor.execute(
+            "INSERT INTO subscriptions (id, user_id, tier, status, created_at, expires_at, paypal_subscription_id) VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (sub_id, user_id, tier, "pending", start_date, None, subscription_data["id"])
+        )
+        
+        conn.commit()
+        conn.close()
+        
+        # Return success with approval URL
+        return True, {
+            "subscription_id": subscription_data["id"],
+            "approval_url": approval_url,
+            "tier": tier
+        }
+        
+    except Exception as e:
+        logger.error(f"Error creating user subscription: {str(e)}")
+        return False, f"Error creating subscription: {str(e)}"
+
+# Add a function to cancel a subscription
+def cancel_subscription(subscription_id, reason="Customer requested cancellation"):
+    """
+    Cancel a PayPal subscription
+    
+    Args:
+        subscription_id: The PayPal subscription ID
+        reason: The reason for cancellation
+        
+    Returns:
+        tuple: (success, result)
+            - success: True if successful, False otherwise
+            - result: Success message or error message
+    """
+    try:
+        # Cancel the subscription with PayPal
+        payload = {
+            "reason": reason
+        }
+        
+        success, result = call_paypal_api(
+            f"/v1/billing/subscriptions/{subscription_id}/cancel", 
+            "POST", 
+            payload
+        )
+        
+        if not success:
+            return False, result
+        
+        # Update subscription status in database
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        cursor.execute(
+            "UPDATE subscriptions SET status = 'cancelled' WHERE paypal_subscription_id = ?",
+            (subscription_id,)
+        )
+        
+        # Get the user ID for this subscription
+        cursor.execute(
+            "SELECT user_id FROM subscriptions WHERE paypal_subscription_id = ?",
+            (subscription_id,)
+        )
+        user_result = cursor.fetchone()
+        
+        if user_result:
+            # Update user to free tier
+            cursor.execute(
+                "UPDATE users SET subscription_tier = 'free_tier' WHERE id = ?",
+                (user_result[0],)
+            )
+        
+        conn.commit()
+        conn.close()
+        
+        return True, "Subscription cancelled successfully"
+        
+    except Exception as e:
+        logger.error(f"Error cancelling subscription: {str(e)}")
+        return False, f"Error cancelling subscription: {str(e)}"
+
+def verify_subscription_payment(subscription_id):
+    """
+    Verify a subscription payment with PayPal
+    
+    Args:
+        subscription_id: The PayPal subscription ID
+        
+    Returns:
+        tuple: (success, result)
+            - success: True if successful, False otherwise
+            - result: Dictionary with subscription details or error message
+    """
+    try:
+        # Get subscription details from PayPal using our helper
+        success, subscription_data = call_paypal_api(f"/v1/billing/subscriptions/{subscription_id}")
+        if not success:
+            return False, subscription_data  # This is already an error message
+        
+        # Check subscription status
+        status = subscription_data.get("status", "").upper()
+        
+        if status not in ["ACTIVE", "APPROVED"]:
+            return False, f"Subscription is not active: {status}"
+        
+        # Return success with subscription data
+        return True, subscription_data
+        
+    except Exception as e:
+        logger.error(f"Error verifying subscription: {str(e)}")
+        return False, f"Error verifying subscription: {str(e)}"
+
+def verify_paypal_subscription(subscription_id):
+    """
+    Verify a PayPal subscription
+    
+    Args:
+        subscription_id: The PayPal subscription ID
+        
+    Returns:
+        tuple: (success, result)
+    """
+    try:
+        # Skip verification for mock subscriptions
+        if subscription_id.startswith("mock_sub_"):
+            return True, {"status": "ACTIVE"}
+            
+        # For real subscriptions, call PayPal API
+        success, result = call_paypal_api(f"/v1/billing/subscriptions/{subscription_id}", "GET")
+        
+        if success:
+            # Check subscription status
+            if result.get("status") == "ACTIVE":
+                return True, result
+            else:
+                return False, f"Subscription is not active: {result.get('status')}"
+        else:
+            logger.error(f"PayPal API error: {result}")
+            return False, f"Failed to verify subscription: {result}"
+    except Exception as e:
+        logger.error(f"Error verifying PayPal subscription: {str(e)}")
+        return False, f"Error verifying subscription: {str(e)}"
+
+# Add this function to save subscription plans
+def save_subscription_plans(plans):
+    """
+    Save subscription plans to a file
+    
+    Args:
+        plans: Dictionary of plan IDs by tier
+    """
+    try:
+        with open(PLAN_IDS_PATH, 'w') as f:
+            json.dump(plans, f)
+        logger.info(f"Saved subscription plans to {PLAN_IDS_PATH}")
+        return True
+    except Exception as e:
+        logger.error(f"Error saving subscription plans: {str(e)}")
+        return False

requirements.txt

@@ -0,0 +1,21 @@
+fastapi>=0.95.0
+uvicorn>=0.21.1
+pydantic>=1.10.7
+python-multipart>=0.0.6
+python-dotenv>=1.0.0
+pdfplumber>=0.9.0
+spacy>=3.5.2
+torch>=2.0.0
+transformers>=4.28.1
+sentence-transformers>=2.2.2
+moviepy>=1.0.3
+matplotlib>=3.7.1
+numpy>=1.24.2
+passlib>=1.7.4
+python-jose[cryptography]>=3.3.0
+bcrypt>=4.0.1
+requests>=2.28.2
+SQLAlchemy>=2.0.9
+aiofiles>=23.1.0
+huggingface_hub>=0.16.4
+en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.5.0/en_core_web_sm-3.5.0-py3-none-any.whl