Initial deploy to HF Spaces (Docker)

.env

@@ -1,8 +1,4 @@
-# .env — local development only (do NOT commit to git)
-# Place this file next to verification.py
-
 DB_USER=admin
 DB_PASSWORD=Pykara123
-
-# Run once to create tables, then change to 0 or remove.
 RUN_INIT_DB=0
+COHERE_API_KEY=WjnDKknACe0zxHvczdo7q4vwF4WAXn2429hcPHIB

.gitignore

@@ -0,0 +1,82 @@
+# -----------------------
+# Python / Flask basics
+# -----------------------
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual envs
+.venv/
+venv/
+env/
+ENV/
+
+# Build / packaging
+build/
+dist/
+*.egg-info/
+.eggs/
+
+# Testing / coverage
+.pytest_cache/
+pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Jupyter
+.ipynb_checkpoints/
+
+# Logs & PIDs
+logs/
+*.log
+*.pid
+
+# OS-specific
+.DS_Store
+Thumbs.db
+
+# IDE / Editor
+.vscode/
+.idea/
+*.iml
+*.code-workspace
+
+# -----------------------
+# App-specific
+# -----------------------
+
+# Local environment files (keep examples if you want)
+.env
+.env.*
+!.env.example
+
+# Credentials / keys (VERY IMPORTANT)
+*.pem
+*.p12
+*.key
+*.crt
+*.cer
+*.der
+*.pfx
+*.enc
+*service-account*.json
+*credentials*.json
+*credential*.json
+*-sa.json
+*secret*.json
+learnenglish-ai-*.json
+gcloud*.json
+
+# Media / generated assets
+static/videos/
+static/audio/
+static/transcripts/
+uploads/
+tmp/
+temp/
+*.tmp
+
+# MoviePy / temp renders (keep source code, ignore big artifacts)
+# (If you actually want to commit sample media, remove these)
+*.moviepy_temp*

requirements.txt

@@ -4,4 +4,11 @@ pyodbc
 bcrypt
 PyJWT
 gunicorn
-python-dotenv
+python-dotenv
+requests
+moviepy
+pydub
+google-cloud-speech
+
+
+

test_moviepy.py

@@ -0,0 +1,1021 @@
+from flask import Flask, jsonify, send_file, abort, make_response, request, Blueprint, current_app
+from flask_cors import CORS
+from moviepy.editor import VideoFileClip
+from google.cloud import speech
+import os
+print(f"GOOGLE_APPLICATION_CREDENTIALS: {os.getenv('GOOGLE_APPLICATION_CREDENTIALS')}")
+import io
+import uuid
+import requests
+from pydub import AudioSegment
+import ffmpeg
+import re 
+import tempfile  # needed by validate-pronounce
+
+app = Flask(__name__)
+CORS(app)
+
+# 👇 Add the helper right here
+def _cohere_headers():
+    api_key = current_app.config.get("COHERE_API_KEY") or COHERE_API_KEY
+    return {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    
+@app.route('/')
+def home():
+    return "Welcome to the Flask app! The server is running."
+
+# Directories for video, audio, and transcripts
+VIDEO_FOLDER = 'static/videos'
+AUDIO_FOLDER = 'static/audio'
+TRANSCRIPT_FOLDER = 'static/transcripts'
+
+# Ensure directories exist
+os.makedirs(VIDEO_FOLDER, exist_ok=True)
+os.makedirs(AUDIO_FOLDER, exist_ok=True)
+os.makedirs(TRANSCRIPT_FOLDER, exist_ok=True)
+
+# API configuration for AI-based question generation
+# COHERE_API_KEY = 'WjnDKknACe0zxHvczdo7q4vwF4WAXn2429hcPHIB'
+COHERE_API_KEY = os.getenv("COHERE_API_KEY", "")
+COHERE_API_URL = 'https://api.cohere.ai/v1/generate'
+
+# Google Cloud Speech-to-Text Configuration
+speech_client = speech.SpeechClient()
+
+# Predefined video metadata
+# VIDEOS = [
+#     {
+#         "id": "1",
+#         "title": "Introduction to AI",
+#         "filename": "ai_intro.mp4"
+#     },
+#     {
+#         "id": "2",
+#         "title": "Machine Learning Basics",
+#         "filename": "ml_basics.mp4"
+#     }
+# ]
+
+
+
+@app.route('/videos', methods=['GET'])
+def list_videos():
+    """
+    List available videos for users to watch.
+    """
+    return jsonify(VIDEOS), 200
+
+@app.route('/videos/<filename>')
+def serve_video(filename):
+    """
+    Serve a video file to the user.
+    """
+    video_path = os.path.join(VIDEO_FOLDER, filename)
+    if not os.path.exists(video_path):
+        print(f"Video file not found: {filename}")
+        abort(404)
+
+    mime_type = 'video/mp4'
+    print(f"Serving video: {filename}, MIME type: {mime_type}")
+    return send_file(video_path, mimetype=mime_type)
+
+
+# Convert video to audio
+def convert_video_to_audio(video_path, audio_path):
+    try:
+        # Using moviepy to extract audio from video
+        video = VideoFileClip(video_path)
+        video.audio.write_audiofile(audio_path, codec='mp3')
+        return audio_path
+    except Exception as e:
+        print(f"Error converting video to audio: {str(e)}")
+        return None
+
+# Re-encode MP3 to ensure proper format
+def reencode_mp3(input_audio_path, output_audio_path):
+    try:
+        # Using pydub to convert and re-encode MP3 (ensuring correct encoding)
+        audio = AudioSegment.from_mp3(input_audio_path)
+        audio.export(output_audio_path, format="mp3", codec="libmp3lame", parameters=["-q:a", "0"])
+        return output_audio_path
+    except Exception as e:
+        print(f"Error re-encoding MP3: {str(e)}")
+        return None
+# Helper function to convert audio to the proper MP3 encoding if necessary
+def convert_audio_to_mp3(input_file_path, output_file_path):
+    """
+    Converts the audio file to a valid MP3 format with proper encoding.
+    """
+    try:
+        ffmpeg.input(input_file_path).output(output_file_path, acodec='libmp3lame', audio_bitrate='128k').run()
+        return True
+    except Exception as e:
+        print(f"Error during audio conversion: {e}")
+        return False
+
+
+# Function to compress audio dynamically
+def compress_audio(input_file_path, output_file_path, target_bitrate="128k"):
+    audio = AudioSegment.from_file(input_file_path)
+    audio.export(output_file_path, format="mp3", bitrate=target_bitrate)
+    return output_file_path
+
+
+@app.route('/upload-video', methods=['POST'])
+def upload_video():
+    print("Received upload request.")
+
+    if 'video' not in request.files:
+        print("No video file provided in the request.")
+        return jsonify({'error': 'No video file provided'}), 400
+
+    video = request.files['video']
+    if video.filename == '':
+        print("Empty filename detected.")
+        return jsonify({'error': 'No selected file'}), 400
+
+    try:
+        filename = str(uuid.uuid4()) + ".mp4"
+        video_path = os.path.join(VIDEO_FOLDER, filename)
+
+        print(f"Saving video: {filename}")
+        video.save(video_path)
+
+        print(f"Video saved successfully at {video_path}")
+        return jsonify({'message': 'Video uploaded successfully!', 'filename': filename}), 200
+
+    except Exception as e:
+        print(f"Error saving video: {str(e)}")
+        return jsonify({'error': 'Failed to save video'}), 500
+
+
+
+
+@app.route('/generate-questions-dynamicvideo', methods=['POST'])
+def generate_questions():
+    try:
+        # Expecting a JSON request body with video filename
+        data = request.json
+        video_filename = data.get('filename')
+
+        if not video_filename:
+            print("Error: No filename provided in request.")
+            return jsonify({"error": "Filename is required"}), 400
+
+        video_path = os.path.join(VIDEO_FOLDER, video_filename)
+        if not os.path.exists(video_path):
+            print(f"Error: Video file {video_filename} not found at {video_path}")
+            return jsonify({"error": "Video file not found"}), 404
+
+        print(f"Processing video: {video_filename}")
+
+        # Convert video to audio
+        audio_filename = f"{uuid.uuid4()}.mp3"
+        audio_path = os.path.join(AUDIO_FOLDER, audio_filename)
+        
+        # Convert video to audio
+        if not convert_video_to_audio(video_path, audio_path):
+            print("Error: Video to audio conversion failed.")
+            return jsonify({"error": "Failed to convert video to audio"}), 500
+
+        # Transcribe audio using Google Cloud Speech-to-Text
+        with open(audio_path, 'rb') as audio_file:
+            audio_content = audio_file.read()
+
+        audio = speech.RecognitionAudio(content=audio_content)
+        config = speech.RecognitionConfig(
+            encoding=speech.RecognitionConfig.AudioEncoding.MP3,
+            sample_rate_hertz=16000,
+            language_code="en-US",
+        )
+
+        response = speech_client.recognize(config=config, audio=audio)
+        transcripts = [result.alternatives[0].transcript for result in response.results]
+
+        if not transcripts:
+            print("Error: No transcription results found.")
+            return jsonify({"error": "No transcription results found"}), 500
+
+        transcription_text = " ".join(transcripts)
+        print(f"Transcription successful: {transcription_text[:200]}...")  # Print first 200 chars
+
+        
+
+        cohere_payload = {
+            "model": "command-r-08-2024",
+            "prompt": f"Generate exactly three multiple-choice questions based on this text:\n{transcription_text}\n"
+                      f"Each question should start with a number followed by a period (e.g., 1.) and should have four options labeled A., B., C., and D. After the options, indicate the correct answer with 'Correct answer: <option letter>' (e.g., Correct answer: A).\n"
+                      f"Please make sure to generate exactly four options per question, and only three questions in total.",
+            "max_tokens": 300,
+            "temperature": 0.9,  # Optional: Control randomness in the responses
+}
+
+        headers = _cohere_headers()
+
+        cohere_response = requests.post(COHERE_API_URL, json=cohere_payload, headers=headers)
+
+        if cohere_response.status_code != 200:
+            print(f"Error: Cohere API response failed: {cohere_response.text}")
+            return jsonify({"error": "Failed to generate questions"}), 500
+
+        questions = cohere_response.json().get("generations", [])
+        if not questions:
+            print("Error: No questions generated from Cohere API.")
+            return jsonify({"error": "No questions generated"}), 500
+
+        # Extract raw text and parse questions
+        raw_text = questions[0]["text"]
+        structured_questions = parse_questions(raw_text)
+
+        return jsonify({"questions": structured_questions}), 200
+
+    except Exception as e:
+        print(f"Critical Error: {e}")
+        return jsonify({"error": "An error occurred while generating questions"}), 500
+
+
+
+
+def parse_questions(response_text):
+    # Split the text into individual question blocks
+    question_blocks = response_text.split("\n\n")
+    questions = []
+
+    # Process each question block
+    for block in question_blocks:
+        print("\nProcessing Block:", block)  # Debug: Log each question block
+
+        # Split the block into lines
+        lines = block.strip().split("\n")
+        print("Split Lines:", lines)  # Debug: Log split lines of the block
+
+        # Ensure the block contains a question
+        if len(lines) < 2:
+            print("Skipping Invalid Block")  # Debug: Log invalid blocks
+            continue
+
+        # Extract the question text
+        question_line = lines[0]
+        question_text = question_line.split(". ", 1)[1] if ". " in question_line else question_line
+        print("Question Text:", question_text)  # Debug: Log extracted question text
+
+        # Extract the options and find the correct answer
+        options = []
+        correct_answer_letter = None
+        for line in lines[1:]:
+            line = line.strip()
+            match = re.match(r"^(?:[a-dA-D][).]?\s)?(.+)$", line)  # Regex to handle `a)`, `A.`, etc.
+            if match:
+                option_text = match.group(1).strip()
+                # Check if this line contains the correct answer
+                if option_text.startswith("Correct answer:"):
+                    correct_answer_letter = option_text.split(":")[-1].strip()
+                else:
+                    options.append(option_text)
+        print("Extracted Options:", options)  # Debug: Log extracted options
+        print("Correct Answer Letter:", correct_answer_letter)  # Debug: Log the correct answer letter
+
+        # Map the correct answer text
+        correct_answer_text = ""
+        if correct_answer_letter:
+            option_index = ord(correct_answer_letter.upper()) - ord('A')  # Convert 'A' to index 0, 'B' to index 1, etc.
+            if 0 <= option_index < len(options):
+                correct_answer_text = options[option_index]
+        print("Mapped Correct Answer Text:", correct_answer_text)  # Debug: Log mapped answer
+
+        # Append the parsed question to the list
+        questions.append({
+            "question": question_text,
+            "options": options,
+            "answer": correct_answer_text  # Use the full answer text
+        })
+
+    print("\nFinal Questions:", questions)  # Debug: Log final parsed questions
+    return questions
+
+
+generated_topics = set()
+
+
+@app.route('/generate-writing-topics', methods=['POST'])
+def generate_writing_topics():
+    """
+    Generate writing topics based on the user's grade level.
+    """
+    try:
+        # Extract grade level from the POST request
+        data = request.json
+        grade_level = data.get("grade_level", "lower").lower()  # Default to 'lower' if not provided
+
+        # Validate grade level
+        valid_levels = {"lower", "middle", "upper"}
+        if grade_level not in valid_levels:
+            return jsonify({"error": f"Invalid grade level. Choose from: {', '.join(valid_levels)}"}), 400
+
+        # Define a prompt based on the grade level
+        if grade_level == "lower":
+            prompt = (
+                "Generate one simple and short writing topic suitable for a lower-grade student. "
+                "The topic should be one sentence, easy to understand, and fun to write about. "
+                "Focus on familiar and relatable themes like family, school, or favorite activities."
+            )
+        elif grade_level == "middle":
+            prompt = (
+                "Generate one creative writing topic suitable for a middle-grade student. "
+                "The topic should encourage imagination and exploration while still being age-appropriate. "
+                "Include themes like adventures, problem-solving, or hypothetical scenarios."
+            )
+        elif grade_level == "upper":
+            prompt = (
+                "Generate one challenging and thought-provoking writing topic suitable for an upper-grade student. "
+                "The topic should require critical thinking, creativity, or self-reflection. "
+                "Include themes like ethical dilemmas, futuristic ideas, or personal experiences."
+            )
+
+        # Call Cohere API to generate topics
+        payload = {
+            "model": "command-r-08-2024",
+            "prompt": prompt,
+            "max_tokens": 150,
+            "temperature": 0.9
+        }
+        headers = _cohere_headers()
+        response = requests.post(COHERE_API_URL, json=payload, headers=headers)
+
+        if response.status_code != 200:
+            return jsonify({"error": "Failed to generate topics"}), 500
+
+        # Extract the generated text
+        raw_text = response.json().get("generations", [])[0].get("text", "")
+        topics = [topic.strip() for topic in raw_text.split("\n") if topic.strip()]
+
+        # Return the generated topics
+        return jsonify({"topics": topics}), 200
+
+    except Exception as e:
+        print(f"Error generating writing topics: {e}")
+        return jsonify({"error": "An error occurred while generating topics"}), 500
+
+
+
+
+@app.route('/validate-response', methods=['POST'])
+def validate_response():
+    """
+    Validate user response against the provided topic using AI.
+    """
+    try:
+        # Extract user input and topic from the request
+        data = request.json
+        topic = data.get("topic")
+        response = data.get("response")
+
+        if not topic or not response:
+            return jsonify({"error": "Both 'topic' and 'response' fields are required."}), 400
+
+        # Define a prompt for validation
+        # prompt = (
+        #     f"You are an English teacher. Evaluate if the following response matches the given topic. "
+        #     f"Topic: '{topic}'. Response: '{response}'. "
+        #     f"Provide feedback on relevance, grammar, and clarity. If the response is unrelated, suggest improvements to align it with the topic."
+        # )
+
+        prompt = (
+    f"You are a writing teacher. Evaluate the sentence formation, grammar, and overall writing quality of the following response. "
+    f"Provide constructive feedback highlighting any errors in grammar, spelling, punctuation, and sentence structure. "
+    f"If the response is well-written, acknowledge its strengths. "
+    f"Topic: '{topic}'. Response: '{response}'."
+)
+
+
+        # Call Cohere API for validation
+        payload = {
+            "model": "command-r-08-2024",
+            "prompt": prompt,
+            "max_tokens": 500,
+            "temperature": 0.7
+        }
+        headers = _cohere_headers()
+        api_response = requests.post(COHERE_API_URL, json=payload, headers=headers)
+
+        if api_response.status_code != 200:
+            return jsonify({"error": "Failed to validate response"}), 500
+
+        # Extract AI feedback
+        feedback = api_response.json().get("generations", [])[0].get("text", "")
+
+        return jsonify({"feedback": feedback}), 200
+
+    except Exception as e:
+        print(f"Error validating response: {e}")
+        return jsonify({"error": "An error occurred while validating the response."}), 500
+
+# Pronounciation
+
+@app.route('/validate-pronounce', methods=['POST'])
+def validate():
+    # Get the word and audio from the request
+    target_word = request.form['word']
+    audio_file = request.files['audio']
+
+    # Save the audio file temporarily
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
+        audio_path = tmp_file.name
+        audio_file.save(audio_path)
+
+    # Transcribe the audio and validate the pronunciation
+    transcribed_word = transcribe_audio(audio_path)
+    os.remove(audio_path)  # Clean up the temporary file
+
+    if not transcribed_word:
+        return jsonify({
+            "success": False,
+            "message": "Could not understand the pronunciation."
+        })
+
+    is_correct, message = validate_pronunciation(target_word, transcribed_word)
+    return jsonify({
+        "success": is_correct,
+        "message": message,
+        "transcribed_word": transcribed_word
+    })
+
+
+@app.route('/teach', methods=['GET'])
+def teach():
+    # Get the word to teach
+    word = request.args.get('word', default='', type=str)
+    if not word:
+        return jsonify({"success": False, "message": "No word provided."})
+
+    # Teach the pronunciation details
+    syllables = get_syllables(word)
+    silent_letters = detect_silent_letters(word)
+
+    return jsonify({
+        "success": True,
+        "syllables": syllables,
+        "silent_letters": silent_letters
+    })
+
+
+
+# Dictionary to store user conversations
+user_sessions = {}
+# Endpoint to explain grammar topics
+movie_bp = Blueprint("movie", __name__)
+
+def _cohere_generate(prompt: str, max_tokens: int = 1000, temperature: float = 0.7):
+    api_key = current_app.config.get("COHERE_API_KEY") or COHERE_API_KEY
+    if not api_key:
+        return None, ("COHERE_API_KEY not set on the server", 500)
+
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {"model": "command-r-08-2024", "prompt": prompt, "max_tokens": max_tokens, "temperature": temperature}
+    try:
+        r = requests.post(COHERE_API_URL, headers=headers, json=payload, timeout=30)
+        if r.status_code != 200:
+            return None, (f"Cohere API error: {r.text}", 502)
+        text = r.json().get("generations", [{}])[0].get("text", "").strip()
+        return text, None
+    except Exception as e:
+        current_app.logger.exception("Cohere request failed: %s", e)
+        return None, ("Upstream request failed", 502)
+
+@movie_bp.post("/explain-grammar")
+def explain_grammar():
+    try:
+        data = request.get_json()
+        print("Received Data:", data) 
+        topic = data.get('topic', '').strip()
+        session_id = data.get('session_id', str(uuid.uuid4()))  # Use provided session_id or create a new one
+
+        if not topic:
+            return jsonify({'error': 'Topic is required'}), 400
+
+        # Retrieve previous conversation history
+        conversation_history = user_sessions.get(session_id, [])
+
+        # Keep the last 10 messages to maintain better context (adjustable)
+        if len(conversation_history) > 10:
+            conversation_history = conversation_history[-10:]
+
+        # Generate a more **adaptive** prompt
+        context = "\n".join(conversation_history) if conversation_history else ""
+
+        prompt = f"""
+        You are a highly skilled grammar assistant. Your job is to maintain a **dynamic conversation** and respond intelligently based on user input, If the user asks something **unrelated to grammar**, respond with: "Please send a grammar-related question..
+
+        - Your answers must always **relate to the conversation history** and **extend naturally** based on what was previously asked.
+        - Your answers must be **concise, clear, and to the point**
+        - If the user asks for **examples**, explanations, or clarifications, **automatically infer** which topic they are referring to.
+        - If the user's question is **vague**, determine the most **logical continuation** based on prior questions.
+        - If the user asks something **unrelated to grammar**, respond with: "Please send a grammar-related question."
+
+        **Conversation so far:**
+        {context}
+
+        **User's new question:** {topic}
+        Please provide a **coherent and relevant answer** that continues the conversation naturally.
+        """
+
+        # Make the API call to Cohere
+        headers = {
+            'Authorization': f'Bearer {COHERE_API_KEY}',
+            'Content-Type': 'application/json'
+        }
+
+        payload = {
+            'model': 'command-r-08-2024',
+            'prompt': prompt,
+            'max_tokens': 1000  # Increased to allow better explanations
+        }
+
+        response = requests.post(COHERE_API_URL, headers=headers, json=payload)
+
+        if response.status_code == 200:
+            ai_response = response.json().get('generations', [{}])[0].get('text', '').strip()
+
+            # Store conversation history to maintain context
+            conversation_history.append(f"User: {topic}\nAI: {ai_response}")
+            user_sessions[session_id] = conversation_history  # Update session history
+
+            return jsonify({'response': ai_response, 'session_id': session_id})
+        else:
+            return jsonify({'error': 'Failed to fetch data from Cohere API'}), 500
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+
+@app.route('/suggest-grammar-questions', methods=['POST'])
+def suggest_grammar_questions():
+    try:
+        data = request.get_json()
+        user_input = data.get('input', '').strip()  # User's partial input (e.g., "What is v")
+
+        if not user_input:
+            return jsonify({'error': 'Input is required'}), 400
+
+        
+
+        prompt = f"""
+			You are a grammar expert. Given the user's input "{user_input}", generate **3 natural grammar-related questions** that people might ask.
+
+			- The user's input is a **partial or full grammar-related query**.
+			- AI must **infer the most likely grammar topic** based on the input.
+			- AI must **ensure all suggestions are strictly related to English grammar**.
+			- **If the input is incomplete, intelligently complete it** with the most likely grammar concept.
+			- Ensure all **questions are fully formed and relevant**.
+
+			**User input:** "{user_input}"
+			Provide exactly 3 well-structured, grammar-related questions:
+			"""
+
+        # Call Cohere API
+        headers = {
+            'Authorization': f'Bearer {COHERE_API_KEY}',
+            'Content-Type': 'application/json'
+        }
+
+        payload = {
+            'model': 'command-r-08-2024',
+            'prompt': prompt,
+            'max_tokens': 100,  # Only short responses needed
+            'temperature': 0.9,  # Some randomness for variety
+            'frequency_penalty': 0.8,  # Reduce repeated words
+            'presence_penalty': 0.8  # Encourage diverse questions
+        }
+
+        response = requests.post(COHERE_API_URL, headers=headers, json=payload)
+
+        if response.status_code == 200:
+            suggestions = response.json().get('generations', [{}])[0].get('text', '').strip().split("\n")
+            return jsonify({'suggestions': suggestions})
+        else:
+            return jsonify({'error': 'Failed to fetch suggestions', 'details': response.text}), 500
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+def validate_topic(topic):
+
+
+
+    validation_prompt = f"""
+    You are an AI grammar expert. Your task is to determine if a given topic is related to **English grammar** or not.
+
+    **Input:** "{topic}"
+
+    ### **Rules:**
+    - If the input is **in the form of a question** (e.g., it asks for an explanation or definition), return `"ask grammar topics"`, even if the topic is related to grammar.
+    - If the topic is **related to English grammar concepts** such as **parts of speech**, **verb tenses**, **sentence structure**, etc., return `"Grammar"`.
+    - If the topic is **not related to grammar**, such as general knowledge, science, math, history, or topics from other fields, return `"Not Grammar"`.
+    - Your response must be based purely on whether the topic relates to grammar, and **not** based on specific words, phrases, or examples.
+
+    **Your response must be exactly either "Grammar", "Not Grammar", or "ask grammar topics". No extra text.**
+    """
+
+
+    
+
+
+    headers = {
+        'Authorization': f'Bearer {COHERE_API_KEY}',
+        'Content-Type': 'application/json'
+    }
+
+    payload = {
+        'model': 'command-r-08-2024',
+        'prompt': validation_prompt,
+        'max_tokens': 5  # Minimal token usage for classification
+    }
+
+    try:
+        response = requests.post(COHERE_API_URL, json=payload, headers=headers)
+        validation_result = response.json().get('generations', [{}])[0].get('text', '').strip()
+        
+        # Ensure the response is strictly "Grammar" or "Not Grammar"
+        if validation_result not in ["Grammar", "Not Grammar"]:
+            return "Not Grammar"  # Fallback to avoid incorrect responses
+
+        return validation_result
+
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+@app.route('/generate-questions', methods=['POST'])
+def generate_questions_test():
+    try:
+        data = request.get_json()
+        topic = data.get('topic', '').strip() # Default to "grammar" if no topic is provided
+        # levels = data.get('levels', ['basic', 'medium', 'hard'])
+
+
+        validation_result = validate_topic(topic)
+
+        if validation_result != "Grammar":
+            return jsonify({"message": "Please enter a valid **grammar topic**, not a general word or unrelated question."}), 400
+
+
+        difficulty = data.get('difficulty', 'basic')
+
+
+         # Debugging output
+        print(f"Generating {difficulty} questions for topic: {topic}")
+
+
+
+        if difficulty == 'basic':
+            prompt = f"""
+            Generate five **completely new and unique** very basic-level fill-in-the-blank grammar questions **every time** on the topic '{topic}'. 
+
+            ### Rules:
+            - **Each question must have a different theme**, ensuring variety.
+            - **Do not repeat** themes from previous generations.
+            - Use **different sentence structures**, avoiding predictable patterns.
+            - **Avoid long words or abstract concepts**
+            - **Focus on the topic '{topic}'**, and ensure the blank is the key part of speech.
+            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
+            - The vocabulary should be **simple and suitable for beginners**.
+            - Ensure that the questions are **always new and distinct**, avoiding previously used themes.
+
+            Do not include any explanations or instructions in the response—only the five unique questions.
+            """
+
+        elif difficulty == 'elementary':
+            prompt = f"""
+            Generate five **completely new and unique** elementary-level fill-in-the-blank grammar questions **every time** on the topic '{topic}'.
+
+            ### Rules:
+            - The questions should be **slightly more challenging than basic-level questions**, incorporating **a wider range of sentence structures and vocabulary**.
+            - **Each question must have a different theme**, ensuring variety.
+            - **Use varied sentence structures**, making them slightly more complex than basic-level questions.
+            - **Ensure that the vocabulary is still simple but slightly broader** than basic-level questions.
+            - **Focus on the topic '{topic}'**, and ensure the blank is the key part of speech.
+            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
+            - Ensure that the questions are **always new and distinct**, avoiding previously used themes.
+    
+            Do not include any explanations or instructions in the response—only the five unique questions.
+            """
+
+        elif difficulty == 'pre-intermediate':
+            prompt = f"""
+            Generate five **completely new and unique** pre-intermediate-level fill-in-the-blank grammar questions **every time** on the topic '{topic}'.
+
+            ### Rules:
+            - The questions should be **more challenging than elementary-level questions**, incorporating **more varied sentence structures and an expanded vocabulary**.
+            - **Each question must have a different theme**, ensuring variety.
+            - **Ensure that the vocabulary is broader than elementary-level**, while keeping it understandable for learners.
+            - **Sentences should be longer and more descriptive** but still clear.
+            - **Focus on the topic '{topic}'**, and ensure the blank is the key part of speech.
+            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
+            - Ensure that the questions are **always new and distinct**, avoiding previously used themes.
+
+            Do not include any explanations or instructions in the response—only the five unique questions.
+            """
+
+        elif difficulty == 'intermediate':
+            prompt = f"""
+            Generate five **completely new and unique** intermediate-level fill-in-the-blank grammar questions **every time** on the topic '{topic}'.
+
+            ### Rules:
+            - The questions should be **more complex than pre-intermediate-level questions**, incorporating **a wider range of vocabulary and sentence structures**.
+            - **Each question must have a different theme**, ensuring variety.
+            - **Ensure that the vocabulary is more advanced than pre-intermediate-level** while keeping it natural for learners.
+            - **Sentences should be longer and include more detail**, improving reading comprehension.
+            - **Focus on the topic '{topic}'**, and ensure the blank is the key part of speech.
+            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
+            - Ensure that the questions are **always new and distinct**, avoiding previously used themes.
+
+            Do not include any explanations or instructions in the response—only the five unique questions.
+            """
+
+        elif difficulty == 'upper-intermediate':
+            prompt = f"""
+            Generate five **completely new and unique** upper-intermediate-level fill-in-the-blank grammar questions **every time** on the topic '{topic}'.
+
+            ### Rules:
+            - The questions should be **more complex than intermediate-level questions**, incorporating **more advanced sentence structures and vocabulary**.
+            - **Each question must have a different theme**, ensuring variety.
+            - **Ensure that the vocabulary is more refined and diverse** but still understandable for upper-intermediate learners.
+            - **Sentences should be longer and may introduce more nuanced contexts**, requiring a deeper understanding.
+            - **Focus on the topic '{topic}'**, and ensure the blank is the key part of speech.
+            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
+            - Ensure that the questions are **always new and distinct**, avoiding previously used themes.
+
+            Do not include any explanations or instructions in the response—only the five unique questions.
+            """
+
+        elif difficulty == 'advanced':
+            prompt = f"""
+            Generate five **completely new and unique** advanced-level (C1) fill-in-the-blank grammar questions **every time** on the topic '{topic}'.
+
+            ### Rules:
+            - The questions should be **more challenging than upper-intermediate (B2) level**, requiring a deep understanding of grammar, context, and vocabulary.
+            - **Ensure varied and sophisticated vocabulary**, avoiding basic words.
+            - **Each question should require nuanced comprehension**, testing knowledge of advanced grammar patterns.
+            - **The blank must be the key part of the sentence** (not an obvious answer).
+            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
+            - Ensure that the questions are **always new and distinct**, avoiding repetition of themes.
+
+            Do not include any explanations or instructions in the response—only the five unique questions.
+            """
+
+        elif difficulty == 'hard':
+            prompt = f"""
+            Generate five **completely new and unique** hard-level (C2) fill-in-the-blank grammar questions **every time** on the topic '{topic}'.
+
+            ### Rules:
+            - The questions should be **more challenging than advanced(C1) level**, requiring a deep understanding of grammar, context, and vocabulary.
+            - **Ensure varied and sophisticated vocabulary**, avoiding basic words.
+            - **Each question should require nuanced comprehension**, testing knowledge of advanced grammar patterns.
+            - **The blank must be the key part of the sentence** (not an obvious answer).
+            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
+            - Ensure that the questions are **always new and distinct**, avoiding repetition of themes.
+
+            Do not include any explanations or instructions in the response—only the five unique questions.
+            """
+
+        else:
+            return jsonify({"error": "Invalid difficulty level"}), 400
+
+        headers = {
+            'Authorization': f'Bearer {COHERE_API_KEY}',
+            'Content-Type': 'application/json'
+        }
+
+        payload = {
+            'model': 'command-r-08-2024',  # Ensure you're using the right model
+            'prompt': prompt,
+            'max_tokens': 1000  # Increase the token limit if needed
+        }
+
+        # Make the API request
+        response = requests.post(COHERE_API_URL, json=payload, headers=headers)
+
+        # Log the full response for debugging
+        print("Response status code:", response.status_code)
+        print("Response content:", response.text)
+
+        if response.status_code == 200:
+            return jsonify(response.json())  # Return the response from Cohere API
+        else:
+            return jsonify({"error": "Failed to fetch questions", "details": response.text}), 500
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+# Endpoint to validate answers
+@app.route('/validate-answer', methods=['POST'])
+def validate_answer():
+    try:
+        # Get the data from the request
+        data = request.get_json()
+        topic = data.get('topic', '')  # Get the topic
+        question = data.get('question', '')
+        user_answer = data.get('user_answer', '')
+
+        # Validate if the required fields are present
+        if not question or not user_answer or not topic:
+         return jsonify({'error': 'Topic, question, and user answer are required'}), 400
+
+        # Construct the prompt for Cohere API
+        prompt = f"""
+        You are a highly knowledgeable grammar assistant. Validate whether the user's answer to the following question is correct or not based on {topic}. If the answer is incorrect, provide a helpful hint.
+        
+        Topic: {topic}
+        Question: "{question}"
+        User's Answer: "{user_answer}"
+
+        Is the answer correct? If not, please explain why and give a hint.
+        """
+
+        # Headers and payload for the Cohere API request
+        headers = {
+            'Authorization': f'Bearer {COHERE_API_KEY}',
+            'Content-Type': 'application/json'
+        }
+
+        payload = {
+            'model': 'command-r-08-2024',  # Use your model name here
+            'prompt': prompt,
+            'max_tokens': 100,
+            'temperature': 0.7
+        }
+
+        # Make the API call to Cohere
+        response = requests.post(COHERE_API_URL, headers=headers, json=payload)
+
+        # Debugging: Log response status and body
+        print(f"Status Code: {response.status_code}")
+        print(f"Response Body: {response.text}")
+
+        # Check if the request was successful
+        if response.status_code == 200:
+            data = response.json()
+            return jsonify(data)
+        else:
+            return jsonify({'error': 'Failed to fetch data from Cohere API'}), 500
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+
+# // for validating Multiple answer:
+
+# Function to validate an individual answer using Cohere API
+def validate_answer_with_ai(topic, question, user_answer):
+    try:
+        # Construct the prompt for Cohere API
+        prompt = f"""
+        You are a highly knowledgeable grammar assistant. Validate whether the user's answer to the following question is correct or not based on {topic}. If the answer is incorrect, provide a helpful hint.
+
+        Topic: {topic}
+        Question: "{question}"
+        User's Answer: "{user_answer}"
+
+        Is the answer correct? If not, please explain why and give a hint.
+        """
+
+        # Headers for the API request
+        headers = {
+            'Authorization': f'Bearer {COHERE_API_KEY}',
+            'Content-Type': 'application/json'
+        }
+
+        # Construct the payload for Cohere API request
+        payload = {
+            'model': 'command-r-08-2024',  # You can use a different model depending on your needs
+            'prompt': prompt,
+            'max_tokens': 200,
+            'temperature': 0.7,
+            'stop_sequences': ['\n']
+        }
+
+        # Make the POST request to the Cohere API
+        response = requests.post('https://api.cohere.ai/v1/generate', headers=headers, json=payload)
+
+        if response.status_code == 200:
+            result = response.json()
+            # Extract and return the relevant part of the response
+            validation_response = result['generations'][0]['text'].strip()
+            return validation_response
+        else:
+            return f"Error: {response.status_code} - {response.text}"
+
+    except Exception as e:
+        return f"An error occurred: {str(e)}"
+
+
+
+
+# Endpoint to validate multiple answers at once
+@app.route('/validate-all-answers', methods=['POST'])
+def validate_all_answers():
+    try:
+        # Get the list of questions and answers from the request body
+        data = request.get_json()
+        questions = data.get('questions', [])
+
+        if not questions:
+            return jsonify({'error': 'No questions provided'}), 400
+
+        validation_results = []
+
+        # Iterate over the list of questions and validate each answer
+        for item in questions:
+            topic = item.get('topic', '')
+            question = item.get('question', '')
+            user_answer = item.get('user_answer', '')
+
+            if not topic or not question or not user_answer:
+                validation_results.append({
+                    'question': question,
+                    'error': 'Missing required fields (topic, question, or answer).'
+                })
+                continue
+
+            # Validate the answer with the Cohere API
+            validation_response = validate_answer_with_ai(topic, question, user_answer)
+
+            # If the answer is incorrect, generate a hint
+            hint = None
+            if "incorrect" in validation_response.lower() or "not correct" in validation_response.lower():
+                # Generate the hint for the incorrect answer
+                hint = generate_hint(topic, question, user_answer)
+
+            validation_results.append({
+                'question': question,
+                'user_answer': user_answer,
+                'validation_response': validation_response,
+                'hint': hint  # Add hint to the result
+            })
+
+        return jsonify({'results': validation_results})
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+
+def generate_hint(topic, question, user_answer):
+    try:
+        # Construct the prompt for Cohere API to generate a hint for incorrect answers
+        prompt = f"""
+        You are a highly skilled grammar assistant. Your task is to generate a helpful hint for the user to improve their answer based on the following question.
+
+        Topic: {topic}
+        Question: "{question}"
+        User's Answer: "{user_answer}"
+
+        If the user's answer is incorrect, provide a specific, actionable hint to help the user correct their answer.
+        The hint should include:
+        - Explanation of the error made by the user.
+        - A hint on the correct grammatical structure or word form.
+        - A hint on how to structure the sentence correctly **without revealing the exact answer**.
+
+        Please make sure the hint is **clear** and **helpful** for the user, **without revealing the correct answer**.
+        """
+
+        headers = {
+            'Authorization': f'Bearer {COHERE_API_KEY}',
+            'Content-Type': 'application/json'
+        }
+
+        payload = {
+            'model': 'command-r-08-2024',  # Replace with the model you're using
+            'prompt': prompt,
+            'max_tokens': 250,  # Adjust token size as needed
+            'temperature': 0.7,  # Use temperature to control creativity
+        }
+
+        # Make the POST request to Cohere API
+        response = requests.post(COHERE_API_URL, headers=headers, json=payload)
+
+        if response.status_code == 200:
+            result = response.json()
+            # Extract and return the relevant hint from the response
+            hint = result['generations'][0]['text'].strip()
+            return hint
+        else:
+            return f"Error: {response.status_code} - {response.text}"
+
+    except Exception as e:
+        return f"An error occurred: {str(e)}"
+
+
+
+
+
+
+if __name__ == '__main__':
+    # app.run(debug=True)
+    app.register_blueprint(movie_bp, url_prefix='')  # expose /explain-grammar locally
+    app.run(host='0.0.0.0', port=5012, debug=True)

verification.py

@@ -28,6 +28,9 @@ CORS(app, supports_credentials=True, origins=ALLOWED_ORIGINS)
 
 logging.basicConfig(level=logging.INFO)
 
+# NEW: API keys / shared config for blueprints (read from HF Secrets/ENV)
+app.config["COHERE_API_KEY"] = os.getenv("COHERE_API_KEY", "")
+
 # ------------------------------------------------------------------------------
 # SQL Server configuration
 # ------------------------------------------------------------------------------
@@ -136,6 +139,7 @@ def health():
 # ------------------------------------------------------------------------------
 # Auth utilities
 # ------------------------------------------------------------------------------
+from functools import wraps
 def token_required(f):
     @wraps(f)
     def decorated(*args, **kwargs):
@@ -166,7 +170,7 @@ def token_required(f):
     return decorated
 
 # ------------------------------------------------------------------------------
-# Routes
+# Routes (verification/auth only)
 # ------------------------------------------------------------------------------
 @app.get("/dashboard")
 @token_required
@@ -297,6 +301,12 @@ def logout(username):
 def check_auth(username):
     return jsonify({"message": "Authenticated", "username": username}), 200
 
+# ------------------------------------------------------------------------------
+# Register Blueprint: grammar (and later media) lives in testmovie.py
+# ------------------------------------------------------------------------------
+from test_moviepy import movie_bp  # ensure testmovie.py defines movie_bp = Blueprint(...)
+app.register_blueprint(movie_bp, url_prefix="/media")
+
 # ------------------------------------------------------------------------------
 # Local run (Gunicorn will import `verification:app` on Spaces)
 # ------------------------------------------------------------------------------