Update app.py

app.py

@@ -1,15 +1,8 @@
 import gradio as gr
 import os
 import librosa
-import numpy as np
 import zipfile
-from datetime import datetime, timedelta
-import hashlib
-import sqlite3
-import requests
-import jwt
-from cryptography.x509 import load_pem_x509_certificate
-from cryptography.hazmat.backends import default_backend
+from datetime import datetime
 from generalstems import (
     mp3_to_wav,
     demucs_separate,
@@ -17,214 +10,7 @@ from generalstems import (
     detect_key_advanced,
     detect_tempo_advanced
 )
-# -----------------------------
-# Clerk Authentication
-# -----------------------------
-CLERK_SECRET_KEY = os.environ.get("CLERK_SECRET_KEY")
-CLERK_PUBLISHABLE_KEY = "pk_test_ZWFzeS1wb2xlY2F0LTIyLmNsZXJrLmFjY291bnRzLmRldiQ"
-# Fetch Clerk's JWKS (public keys for verification)
-def get_clerk_public_key():
-    """Get Clerk's public key for JWT verification"""
-    try:
-        response = requests.get("https://easy-polecat-22.clerk.accounts.dev/.well-known/jwks.json")
-        jwks = response.json()
-        # Use first key (typically RS256)
-        return jwks['keys'][0]
-    except Exception as e:
-        print(f"[ERROR] Failed to fetch Clerk JWKS: {e}")
-        return None
-def verify_clerk_token(token):
-    """Verify JWT token from Clerk and return user_id"""
-    if not token or not CLERK_SECRET_KEY:
-        return None
 
-    try:
-        # Verify using Clerk API
-        response = requests.get(
-            f"https://api.clerk.com/v1/sessions/verify",
-            headers={
-                "Authorization": f"Bearer {CLERK_SECRET_KEY}",
-                "Content-Type": "application/json"
-            },
-            json={"token": token}
-        )
-
-        if response.status_code == 200:
-            data = response.json()
-            user_id = data.get('user_id')
-            print(f"[AUTH] Verified user: {user_id}")
-            return user_id
-        else:
-            print(f"[AUTH] Verification failed: {response.status_code}")
-            return None
-
-    except Exception as e:
-        print(f"[AUTH ERROR] {e}")
-        return None
-# -----------------------------
-# Usage Limiting System - WITH AUTH
-# -----------------------------
-DB_PATH = "usage_limits.db"
-ANON_MAX_DAILY_USES = 1  # Anonymous users get 1 daily use
-AUTH_MAX_DAILY_USES = 3  # Authenticated users get 3 daily uses
-MAX_MONTHLY_USES = 15
-RESET_HOURS = 24
-def init_db():
-    """Initialize SQLite database for persistent storage"""
-    conn = sqlite3.connect(DB_PATH)
-    # Add clerk_user_id column for authenticated users
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS usage (
-            user_id TEXT PRIMARY KEY,
-            clerk_user_id TEXT,
-            daily_uses INTEGER DEFAULT 0,
-            monthly_uses INTEGER DEFAULT 0,
-            first_daily_use TIMESTAMP,
-            first_monthly_use TIMESTAMP
-        )
-    """)
-    conn.commit()
-    conn.close()
-    print("[INFO] Database initialized")
-init_db()
-def get_user_id(request: gr.Request, clerk_user_id=None):
-    """Create identifier - prioritize Clerk ID, fallback to IP fingerprint"""
-    if clerk_user_id:
-        # Authenticated user - use Clerk ID
-        return f"clerk_{clerk_user_id}"
-
-    try:
-        # Anonymous user - use IP fingerprint
-        ip = request.headers.get("x-forwarded-for", "")
-        if ip and "," in ip:
-            ip = ip.split(",")[0].strip()
-
-        if not ip:
-            ip = request.headers.get("x-real-ip", "")
-        if not ip:
-            ip = request.headers.get("cf-connecting-ip", "")
-        if not ip:
-            ip = request.client.host if hasattr(request, 'client') else ""
-
-        user_agent = request.headers.get("user-agent", "")
-        accept_language = request.headers.get("accept-language", "")
-
-        identifier_string = f"{ip}_{user_agent}_{accept_language}"
-        identifier = hashlib.sha256(identifier_string.encode()).hexdigest()
-        print(f"[DEBUG] Anonymous user ID: {identifier[:12]}... | IP: {ip}")
-        return f"anon_{identifier}"
-    except Exception as e:
-        print(f"[ERROR] Failed to get user ID: {e}")
-        return f"anon_{hashlib.sha256(str(datetime.now()).encode()).hexdigest()}"
-def check_usage_limit(request: gr.Request, clerk_user_id=None):
-    """Check usage limits - authenticated users get 3 daily, anonymous get 1 daily"""
-    user_id = get_user_id(request, clerk_user_id)
-    now = datetime.now()
-    is_authenticated = clerk_user_id is not None
-
-    # Set max daily uses based on auth status
-    max_daily_uses = AUTH_MAX_DAILY_USES if is_authenticated else ANON_MAX_DAILY_USES
-
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-
-    cursor.execute("""
-        SELECT daily_uses, monthly_uses, first_daily_use, first_monthly_use, clerk_user_id
-        FROM usage WHERE user_id = ?
-    """, (user_id,))
-
-    row = cursor.fetchone()
-
-    if row:
-        daily_uses, monthly_uses, first_daily_str, first_monthly_str, stored_clerk_id = row
-        first_daily_use = datetime.fromisoformat(first_daily_str) if first_daily_str else now
-        first_monthly_use = datetime.fromisoformat(first_monthly_str) if first_monthly_str else now
-
-        print(f"[DEBUG] User: {'AUTH' if is_authenticated else 'ANON'} | Daily {daily_uses}/{max_daily_uses}, Monthly {monthly_uses}/{MAX_MONTHLY_USES}")
-
-        # Reset daily counter after 24 hours
-        if now - first_daily_use > timedelta(hours=RESET_HOURS):
-            print(f"[DEBUG] Resetting daily usage")
-            daily_uses = 0
-            first_daily_use = now
-            cursor.execute("""
-                UPDATE usage SET daily_uses = 0, first_daily_use = ? WHERE user_id = ?
-            """, (now.isoformat(), user_id))
-            conn.commit()
-
-        # Reset monthly counter after 30 days
-        if now - first_monthly_use > timedelta(days=30):
-            print(f"[DEBUG] Resetting monthly usage")
-            monthly_uses = 0
-            first_monthly_use = now
-            cursor.execute("""
-                UPDATE usage SET monthly_uses = 0, first_monthly_use = ? WHERE user_id = ?
-            """, (now.isoformat(), user_id))
-            conn.commit()
-
-        # Check daily limit (1 for anonymous, 3 for authenticated)
-        if daily_uses >= max_daily_uses:
-            time_until_reset = (first_daily_use + timedelta(hours=RESET_HOURS)) - now
-            hours = int(time_until_reset.total_seconds() // 3600)
-            minutes = int((time_until_reset.total_seconds() % 3600) // 60)
-            print(f"[DEBUG] DAILY LIMIT HIT")
-            conn.close()
-
-            # If anonymous user hit their limit, prompt to sign in
-            if not is_authenticated:
-                return False, 0, 0, "", "auth_required"
-            else:
-                return False, 0, 0, f"{hours}h {minutes}m", "daily"
-
-        # Check monthly limit (authenticated users only)
-        if is_authenticated and monthly_uses >= MAX_MONTHLY_USES:
-            time_until_reset = (first_monthly_use + timedelta(days=30)) - now
-            days = int(time_until_reset.total_seconds() // 86400)
-            hours = int((time_until_reset.total_seconds() % 86400) // 3600)
-            print(f"[DEBUG] MONTHLY LIMIT HIT")
-            conn.close()
-            return False, 0, 0, f"{days} days {hours}h", "monthly"
-
-        daily_remaining = max_daily_uses - daily_uses
-        monthly_remaining = MAX_MONTHLY_USES - monthly_uses
-
-    else:
-        # New user
-        print(f"[DEBUG] New user - {'AUTH' if is_authenticated else 'ANON'}")
-        cursor.execute("""
-            INSERT INTO usage (user_id, clerk_user_id, daily_uses, monthly_uses, first_daily_use, first_monthly_use)
-            VALUES (?, ?, 0, 0, ?, ?)
-        """, (user_id, clerk_user_id, now.isoformat(), now.isoformat()))
-        conn.commit()
-        daily_remaining = max_daily_uses
-        monthly_remaining = MAX_MONTHLY_USES
-
-    conn.close()
-    print(f"[DEBUG] User allowed - Daily: {daily_remaining}, Monthly: {monthly_remaining}")
-    return True, daily_remaining, monthly_remaining, "", ""
-def increment_usage(request: gr.Request, clerk_user_id=None):
-    """Increment usage counts"""
-    user_id = get_user_id(request, clerk_user_id)
-    is_authenticated = clerk_user_id is not None
-    max_daily_uses = AUTH_MAX_DAILY_USES if is_authenticated else ANON_MAX_DAILY_USES
-
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-
-    cursor.execute("""
-        UPDATE usage 
-        SET daily_uses = daily_uses + 1, monthly_uses = monthly_uses + 1
-        WHERE user_id = ?
-    """, (user_id,))
-
-    conn.commit()
-
-    cursor.execute("SELECT daily_uses, monthly_uses FROM usage WHERE user_id = ?", (user_id,))
-    row = cursor.fetchone()
-    if row:
-        print(f"[DEBUG] Usage incremented - Daily: {row[0]}/{max_daily_uses}, Monthly: {row[1]}/{MAX_MONTHLY_USES}")
-
-    conn.close()
 # -----------------------------
 # Download function
 # -----------------------------
@@ -264,7 +50,7 @@ def create_download_zip(selected_files):
                 }
 
                 filename = file_mapping.get(file_type)
-                if (filename):
+                if filename:
                     file_path = os.path.join("stems", filename)
                     if os.path.exists(file_path):
                         zipf.write(file_path, filename)
@@ -273,27 +59,14 @@ def create_download_zip(selected_files):
     except Exception as e:
         print(f"Error creating zip: {e}")
         return None
+
 # -----------------------------
-# Main processing function - WITH AUTH
+# Main processing function
 # -----------------------------
-def process(song_file, options, auth_token, request: gr.Request):
-    # Verify auth token
-    clerk_user_id = verify_clerk_token(auth_token) if auth_token else None
-
-    # Check usage limit
-    allowed, daily_remaining, monthly_remaining, reset_time, limit_type = check_usage_limit(request, clerk_user_id)
-
-    if not allowed:
-        if limit_type == "auth_required":
-            return [None] * 8 + ["AUTH_REQUIRED"]
-        elif limit_type == "daily":
-            return [None] * 8 + [f"LIMIT_ERROR:DAILY:{reset_time}"]
-        elif limit_type == "monthly":
-            return [None] * 8 + [f"LIMIT_ERROR:MONTHLY:{reset_time}"]
-
+def process(song_file, options):
     try:
         if song_file is None:
-            return [None] * 8 + [f"UPLOAD_REQUIRED:{daily_remaining}:{monthly_remaining}"]
+            return [None] * 8 + ["Please upload a song file"]
 
         out_dir = "stems"
         os.makedirs(out_dir, exist_ok=True)
@@ -325,7 +98,7 @@ def process(song_file, options, auth_token, request: gr.Request):
                 tempo = detect_tempo_advanced(y, sr)
                 song_info = f"Key: {key} | Tempo: {tempo} BPM"
             except Exception as e:
-                song_info = f"INFO_ERROR:{str(e)}"
+                song_info = f"Info detection error: {str(e)}"
                 print(f"Info detection error: {e}")
 
         # WAV conversion
@@ -342,11 +115,7 @@ def process(song_file, options, auth_token, request: gr.Request):
         if "Refine Drums" in options and "drums" in stems:
             drum_refined = refine_drums(stems["drums"], out_dir)
 
-        # Increment usage
-        increment_usage(request, clerk_user_id)
-
-        success_info = song_info if song_info else ""
-        success_info += f"SUCCESS:{daily_remaining - 1}:{monthly_remaining - 1}"
+        success_info = song_info if song_info else "Processing complete!"
 
         return (
             wav_path,
@@ -364,12 +133,13 @@ def process(song_file, options, auth_token, request: gr.Request):
         print(f"Processing error: {e}")
         import traceback
         traceback.print_exc()
-        return [None] * 8 + ["PROCESSING_ERROR"]
+        return [None] * 8 + [f"Processing error: {str(e)}"]
+
 # -----------------------------
 # UI Layout
 # -----------------------------
 with gr.Blocks(title="Stem Splitter") as ui:
-    gr.Markdown("## Stem Splitter API with Authentication")
+    gr.Markdown("## Stem Splitter")
 
     with gr.Row():
         with gr.Column():
@@ -379,7 +149,6 @@ with gr.Blocks(title="Stem Splitter") as ui:
                 value=["All"],
                 label="Options"
             )
-            auth_token_input = gr.Textbox(label="Auth Token (optional)", visible=False)
             song_info = gr.Textbox(label="Status")
             process_btn = gr.Button("Process")
 
@@ -403,7 +172,7 @@ with gr.Blocks(title="Stem Splitter") as ui:
 
     process_btn.click(
         fn=process,
-        inputs=[song_input, process_options, auth_token_input],
+        inputs=[song_input, process_options],
         outputs=[wav_out, vocals, bass, other, drums, kick, snare, hihat, song_info]
     )
 
@@ -412,5 +181,6 @@ with gr.Blocks(title="Stem Splitter") as ui:
         inputs=[download_options],
         outputs=[download_file]
     )
+
 if __name__ == "__main__":
     ui.launch(server_name="0.0.0.0", server_port=7860)