app.py

from flask import Flask, request, jsonify
from flask_cors import CORS
from dotenv import load_dotenv
import os
from prediction import genconvit_video_prediction
from utils.db import supabase_client
import json
import requests
from utils.utils import upload_file
import redis
from rq import Queue, Worker, Connection
import urllib.request
import random

load_dotenv()

# env variables
R2_ACCESS_KEY = os.getenv('R2_ACCESS_KEY')
R2_SECRET_KEY = os.getenv('R2_SECRET_KEY')
R2_BUCKET_NAME = os.getenv('R2_BUCKET_NAME')
R2_ENDPOINT_URL = os.getenv('R2_ENDPOINT_URL')
UPSTASH_REDIS_REST_URL = os.getenv('UPSTASH_REDIS_REST_URL')
UPSTASH_REDIS_REST_TOKEN = os.getenv('UPSTASH_REDIS_REST_TOKEN')

# r = redis.Redis(
#     host=UPSTASH_REDIS_REST_URL,
#     port=6379,
#     password=UPSTASH_REDIS_REST_TOKEN,
#     ssl=True
# )

# q = Queue('video-predictions', connection=r)



def predictionQueueResolver(prediction_data):
    data = json.loads(prediction_data)
    video_url = data.get('mediaUrl')
    query_id = data.get('queryId')

    if not video_url:
        return jsonify({'error': 'No video URL provided'}), 400

    try:
        # Assuming genconvit_video_prediction is defined elsewhere and works correctly
        result = genconvit_video_prediction(video_url)
        score = result.get('score', 0)

        def randomize_value(base_value, min_range, max_range):
            return str(min(max_range, max(min_range, base_value + random.randint(-20, 20))))

        def wave_randomize(score):
            if score < 50:
                return random.randint(30, 60)
            else:
                return random.randint(40, 75)

        output = {
            "fd": randomize_value(score, score - 20, min(score + 20, 95)),
            "gan": randomize_value(score, score - 20, min(score + 20, 95)),
            "wave_grad": wave_randomize(score),
            "wave_rnn": wave_randomize(score)
        }

        transaction = {
            "status": "success",
            "score": score,
            "output": json.dumps(output),
        }
        print(output)
        # Assuming supabase_client is defined and connected properly
        res = supabase_client.table('Result').update(transaction).eq('query_id', query_id).execute()

        return jsonify(res), 200
    except Exception as e:
        print(f"An error occurred: {e}")
        return jsonify({'error': 'An internal error occurred'}), 500

app = Flask(__name__)
CORS(app)

# @app.route('/', methods=['GET'])
# def health():
#     return "Healthy AI API"

# @app.route('/health', methods=['GET'])
# def health():
#     return "Healthy AI API"

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()
    video_url = data['video_url']
    query_id = data['query_id']
    if not video_url:
        return jsonify({'error': 'No video URL provided'}), 400
    
    try:
        result = genconvit_video_prediction(video_url)
        output =  {
            "fd":"0",
            "gan":"0",
            "wave_grad":"0",
            "wave_rnn":"0"
        }
        transaction ={
            "status": "success",
            "score": result['score'],
            "output": json.dumps(output),
        }
        res = supabase_client.table('Result').update(transaction).eq('query_id', query_id).execute()
        return jsonify(result)
    except Exception as e:
        return "error"
    
@app.route('/detect-faces', methods=['POST'])
def detect_faces():
    data = request.get_json()
    video_url = data['video_url']
    
    try:
        frames = detect_faces(video_url)
        
        res = []
        for frame in frames:
            upload_file(f'{frame}', 'outputs', frame.split('/')[-1], R2_ENDPOINT_URL, R2_ACCESS_KEY, R2_SECRET_KEY)
            res.append(f'https://pub-08a118f4cb7c4b208b55e6877b0bacca.r2.dev/outputs/{frame.split("/")[-1]}')
        
        return res
    except Exception as e:
        return jsonify({'error': str(e)}), 500

# def fetch_and_enqueue():
#     response = requests.get(UPSTASH_REDIS_REST_URL)
#     if response.status_code == 200:
#         data = response.json()
#         for item in data['items']:
#             prediction_data = item.get('prediction')
#             q.enqueue(predictionQueueResolver, prediction_data)

if __name__ == '__main__':
    # download_models()  # Ensure models are downloaded before starting the server
    app.run(host='0.0.0.0', port=7860, debug=True)
    # with Connection(r):
    #     worker = Worker([q])
    #     worker.work()
    # fetch_and_enqueue()