Upload 8 files

src/audioProcessing.py

@@ -0,0 +1,57 @@
+import os
+import tempfile
+import requests
+import json
+import uuid
+from typing import Tuple, Optional, Dict, Any
+
+def transcribe_audio(audio_file, api_key, model_id="scribe_v1"):
+    if not api_key:
+        return {"error": "Please provide an API key"}
+    url = "https://api.elevenlabs.io/v1/speech-to-text"
+    headers = {
+        "xi-api-key": api_key
+    }
+    files = {
+        "file": open(audio_file, "rb"),
+        "model_id": (None, model_id)
+    }
+    try:
+        response = requests.post(url, headers=headers, files=files)
+        response.raise_for_status()
+        result = response.json()
+        return result
+    except requests.exceptions.RequestException as e:
+        return {"error": f"API request failed: {str(e)}"}
+    except json.JSONDecodeError:
+        return {"error": "Failed to parse API response"}
+    finally:
+        files["file"].close()
+
+def save_transcription(transcription):
+    if "error" in transcription:
+        return None, transcription["error"]
+    transcript_filename = f"transcription_{uuid.uuid4().hex[:8]}.txt"
+    try:
+        with open(transcript_filename, "w", encoding="utf-8") as f:
+            f.write(transcription.get('text', 'No text found'))
+        return transcript_filename, "Transcription saved as text file"
+    except Exception as e:
+        return None, f"Error saving transcription: {str(e)}"
+
+def process_audio_file(audio_file, elevenlabs_api_key, model_id="scribe_v1") -> Tuple[str, str, str]:
+    if not elevenlabs_api_key:
+        return None, "ElevenLabs API key is required for transcription", None
+    
+    transcription_result = transcribe_audio(audio_file, elevenlabs_api_key, model_id)
+    
+    if "error" in transcription_result:
+        return None, transcription_result["error"], None
+    
+    transcript_text = transcription_result.get('text', '')
+    transcript_path = tempfile.mktemp(suffix='.txt')
+    
+    with open(transcript_path, 'w', encoding='utf-8') as transcript_file:
+        transcript_file.write(transcript_text)
+    
+    return transcript_path, f"Transcription completed successfully. Length: {len(transcript_text)} characters.", transcript_text

src/documentProcessing.py

@@ -0,0 +1,61 @@
+import docx
+import PyPDF2
+
+def extract_text_from_pdf(pdf_path):
+    text = ""
+    try:
+        with open(pdf_path, 'rb') as file:
+            reader = PyPDF2.PdfReader(file)
+            for page_num in range(len(reader.pages)):
+                text += reader.pages[page_num].extract_text() + "\n"
+        return text
+    except Exception as e:
+        raise Exception(f"Error extracting text from PDF: {str(e)}")
+
+def extract_text_from_docx(docx_path):
+    try:
+        doc = docx.Document(docx_path)
+        text = "\n".join([paragraph.text for paragraph in doc.paragraphs])
+        return text
+    except Exception as e:
+        raise Exception(f"Error extracting text from DOCX: {str(e)}")
+
+def extract_text_from_txt(txt_path):
+    try:
+        with open(txt_path, 'r', encoding='utf-8') as file:
+            text = file.read()
+        return text
+    except Exception as e:
+        raise Exception(f"Error extracting text from TXT: {str(e)}")
+
+def process_document(document_path, gemini_api_key, language, content_type):
+    try:
+        temp_file = tempfile.mktemp(suffix=os.path.splitext(document_path.name)[-1])
+        with open(temp_file, 'wb') as f:
+            f.write(document_path.read())
+        
+        file_extension = os.path.splitext(document_path.name)[-1].lower()
+        if file_extension == '.pdf':
+            text = extract_text_from_pdf(temp_file)
+        elif file_extension == '.docx':
+            text = extract_text_from_docx(temp_file)
+        elif file_extension == '.txt':
+            text = extract_text_from_txt(temp_file)
+        else:
+            raise Exception(f"Unsupported file type: {file_extension}")
+        
+        text_file_path = tempfile.mktemp(suffix='.txt')
+        with open(text_file_path, 'w', encoding='utf-8') as f:
+            f.write(text)
+        
+        formatted_output, json_path, txt_path = analyze_document(
+            text, 
+            gemini_api_key, 
+            language, 
+            content_type
+        )
+        
+        return f"Document processed successfully", text_file_path, formatted_output, txt_path, json_path
+    except Exception as e:
+        error_message = f"Error processing document: {str(e)}"
+        return error_message, None, error_message, None, None

src/mainFunctions.py

@@ -0,0 +1,146 @@
+import os
+import tempfile
+import subprocess
+from typing import Optional, Tuple, List
+import pytube
+from src.video_processing import extract_audio_from_video
+from src.quiz_processing import analyze_document
+import docx
+import PyPDF2
+import re
+
+
+def parse_quiz_content(quiz_text):
+    questions = []
+    lines = quiz_text.split('\n')
+    current_question = None
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+            
+        q_match = re.match(r'^(?:\d+\.|\[?Q\d+\]?\.?)\s+(.*)', line, re.IGNORECASE)
+        if q_match:
+            if current_question:
+                questions.append(current_question)
+            current_question = {"question": q_match.group(1), "answer": ""}
+        elif current_question and line.lower().startswith(("answer:", "a:", "ans:")):
+            answer_text = re.sub(r'^(?:answer:|a:|ans:)\s*', '', line, flags=re.IGNORECASE)
+            current_question["answer"] = answer_text.strip()
+    
+    if current_question:
+        questions.append(current_question)
+        
+    return {"questions": questions}
+
+
+def transcribe_audio(audio_path, elevenlabs_api_key, model_id):
+    import requests
+    import json
+    
+    try:
+        with open(audio_path, 'rb') as audio_file:
+            response = requests.post(
+                'https://api.elevenlabs.io/v1/transcribe',
+                headers={'xi-api-key': elevenlabs_api_key},
+                files={'audio': audio_file},
+                data={'model_id': model_id}
+            )
+        
+        if response.status_code == 200:
+            transcription = response.json().get('transcription', '')
+            
+            transcript_path = tempfile.mktemp(suffix='.txt')
+            with open(transcript_path, 'w', encoding='utf-8') as f:
+                f.write(transcription)
+                
+            return transcription, transcript_path, "Transcription completed successfully"
+        else:
+            return None, None, f"Transcription failed: {response.text}"
+    except Exception as e:
+        return None, None, f"Transcription error: {str(e)}"
+
+def process_video_file(video_path, audio_format, elevenlabs_api_key, model_id, gemini_api_key, language, content_type):
+    try:
+        audio_path = extract_audio_from_video(video_path, audio_format)
+        
+        transcription, transcript_path, transcription_status = transcribe_audio(
+            audio_path, 
+            elevenlabs_api_key, 
+            model_id
+        )
+        
+        if not transcription:
+            return audio_path, "Audio extracted, but transcription failed", None, transcription_status, None, None, None
+        
+        formatted_output, json_path, txt_path = analyze_document(
+            transcription, 
+            gemini_api_key, 
+            language, 
+            content_type
+        )
+        
+        return audio_path, "Processing completed successfully", transcript_path, transcription_status, formatted_output, txt_path, json_path
+    except Exception as e:
+        error_message = f"Error processing video: {str(e)}"
+        return None, error_message, None, error_message, error_message, None, None
+
+def process_youtube_video(youtube_url, audio_format, elevenlabs_api_key, model_id, gemini_api_key, language, content_type):
+    try:
+        yt = pytube.YouTube(youtube_url)
+        stream = yt.streams.filter(progressive=True, file_extension='mp4').order_by('resolution').desc().first()
+        
+        if not stream:
+            raise Exception("No suitable video stream found")
+        
+        # Download to temporary file
+        video_path = tempfile.mktemp(suffix='.mp4')
+        stream.download(filename=video_path)
+        audio_path = extract_audio_from_video(video_path, audio_format)
+        
+        transcription, transcript_path, transcription_status = transcribe_audio(
+            audio_path, 
+            elevenlabs_api_key, 
+            model_id
+        )
+        
+        if not transcription:
+            return audio_path, "Audio extracted, but transcription failed", None, transcription_status, None, None, None
+        
+        formatted_output, json_path, txt_path = analyze_document(
+            transcription, 
+            gemini_api_key, 
+            language, 
+            content_type
+        )
+        
+        return audio_path, "Processing completed successfully", transcript_path, transcription_status, formatted_output, txt_path, json_path
+    except Exception as e:
+        error_message = f"Error processing YouTube video: {str(e)}"
+        return None, error_message, None, error_message, error_message, None, None
+
+def process_audio_document(audio_path, elevenlabs_api_key, model_id, gemini_api_key, language, content_type):
+    """Process an audio file - transcribe and generate summary or quiz."""
+    try:
+        transcription, transcript_path, transcription_status = transcribe_audio(
+            audio_path, 
+            elevenlabs_api_key, 
+            model_id
+        )
+        
+        if not transcription:
+            return "Transcription failed", None, None, None, None
+        
+        formatted_output, json_path, txt_path = analyze_document(
+            transcription, 
+            gemini_api_key, 
+            language, 
+            content_type
+        )
+        
+        return "Processing completed successfully", transcript_path, formatted_output, txt_path, json_path
+    except Exception as e:
+        error_message = f"Error processing audio: {str(e)}"
+        return error_message, None, error_message, None, None
+

src/prompts.py

@@ -0,0 +1,96 @@
+SYSTEM_PROMPT = """You are an expert educational content analyzer. Your task is to analyze text content, 
+identify distinct segments, and create high-quality educational quiz questions for each segment."""
+
+SUMMARY_PROMPT_TEMPLATE = """
+You are an expert content analyst specialized in creating professional, actionable summaries of educational content.
+
+Please analyze the following text to create a comprehensive yet concise summary that will be valuable to readers. Your summary should:
+
+1. Begin with a brief overview of the main topic and its significance (2-3 sentences)
+2. Identify and clearly highlight the most important concepts, names, places, and technical terms using markdown formatting (bold for key terms, italics for definitions)
+3. Present key information in organized bullet points grouped by theme or concept
+4. Include specific supporting details, examples, statistics, or quotes that enhance understanding
+5. End with the practical implications or conclusions that can be drawn from the content
+
+The text to analyze is:
+{text}
+
+Respond with a properly formatted JSON object according to this schema:
+{{
+"summary": {{
+"title": "A clear, descriptive title for the content",
+"overview": "A concise overview paragraph introducing the main topic",
+"key_points": [
+{{
+"theme": "First major theme or concept",
+"points": [
+"First key bullet point with important terms highlighted",
+"Second key bullet point with contextual information",
+"Third key bullet point with specific details or examples"
+]
+}},
+{{
+"theme": "Second major theme or concept",
+"points": [
+"First key bullet point for this theme",
+"Second key bullet point for this theme",
+"Additional bullet points as needed"
+]
+}}
+],
+"key_entities": [
+{{
+"name": "Name of person, place, or organization",
+"description": "Brief description of their relevance"
+}},
+{{
+"name": "Another key entity",
+"description": "Brief description of their relevance"
+}}
+],
+"conclusion": "A concise statement summarizing the main implications or takeaways"
+}}
+}}
+
+Focus on creating a summary that is immediately useful, visually scannable, and highlights the most important information. Use markdown formatting strategically to make the summary more readable and engaging.
+"""
+
+
+QUIZ_PROMPT_TEMPLATE = """
+You are an expert quiz creator specialized in creating educational assessments.
+Please analyze the following text and create 10 multiple-choice quiz questions that test understanding of the key concepts and information presented in the text. For each question:
+1. Write a clear, concise question
+2. Create 4 answer options (A, B, C, D)
+The text to analyze is:
+{text}
+Respond with a properly formatted JSON object according to this schema:
+
+{{
+  "quiz_questions": [
+    {{
+      "question": "The full text of the question?",
+      "options": [
+        {{
+          "text": "First option text",
+          "correct": false
+        }},
+        {{
+          "text": "Second option text", 
+          "correct": true
+        }},
+        {{
+          "text": "Third option text",
+          "correct": false
+        }},
+        {{
+          "text": "Fourth option text",
+          "correct": false
+        }}
+      ]
+    }},
+    ... additional questions ...
+  ]
+}}
+
+Create questions that test different levels of understanding, from recall of facts to application of concepts. Ensure the questions cover the most important information from the text.
+"""

src/quiz_processing.py

@@ -0,0 +1,218 @@
+import os
+import re
+import json
+import time
+import tempfile
+from typing import Dict, Any, List, Optional
+from transformers import AutoTokenizer
+from sentence_transformers import SentenceTransformer
+from huggingface_hub import login
+
+GEMINI_MODEL = "gemini-2.0-flash"
+DEFAULT_TEMPERATURE = 0.7
+
+TOKENIZER_MODEL = "answerdotai/ModernBERT-base"
+SENTENCE_TRANSFORMER_MODEL = "all-MiniLM-L6-v2"
+
+hf_token = os.environ.get('HF_TOKEN', None)
+login(token=hf_token)
+
+tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_MODEL)
+sentence_model = SentenceTransformer(SENTENCE_TRANSFORMER_MODEL)
+
+def clean_text(text):
+    text = re.sub(r'\[speaker_\d+\]', '', text)
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+def split_text_by_tokens(text, max_tokens=12000):
+    text = clean_text(text)
+    tokens = tokenizer.encode(text)
+    
+    if len(tokens) <= max_tokens:
+        return [text]
+    
+    split_point = len(tokens) // 2
+    
+    sentences = re.split(r'(?<=[.!?])\s+', text)
+    
+    first_half = []
+    second_half = []
+    
+    current_tokens = 0
+    for sentence in sentences:
+        sentence_tokens = len(tokenizer.encode(sentence))
+        
+        if current_tokens + sentence_tokens <= split_point:
+            first_half.append(sentence)
+            current_tokens += sentence_tokens
+        else:
+            second_half.append(sentence)
+    
+    return [" ".join(first_half), " ".join(second_half)]
+
+def generate_with_gemini(text, api_key, language, content_type="summary"):
+    from langchain_google_genai import ChatGoogleGenerativeAI
+    os.environ["GOOGLE_API_KEY"] = api_key
+    llm = ChatGoogleGenerativeAI(
+        model=GEMINI_MODEL,
+        temperature=DEFAULT_TEMPERATURE,
+        max_retries=3
+    )
+    
+    if content_type == "summary":
+        base_prompt = SUMMARY_PROMPT_TEMPLATE.format(text=text)
+    else:
+        base_prompt = QUIZ_PROMPT_TEMPLATE.format(text=text)
+
+    language_instruction = f"\nIMPORTANT: Generate ALL content in {language} language."
+    prompt = base_prompt + language_instruction
+    
+    try:
+        messages = [
+            {"role": "system", "content": "You are a helpful AI assistant that creates high-quality text summaries and quizzes."},
+            {"role": "user", "content": prompt}
+        ]
+        
+        response = llm.invoke(messages)
+        
+        try:
+            content = response.content
+            json_match = re.search(r'```json\s*([\s\S]*?)\s*```', content)
+            
+            if json_match:
+                json_str = json_match.group(1)
+            else:
+                json_match = re.search(r'(\{[\s\S]*\})', content)
+                if json_match:
+                    json_str = json_match.group(1)
+                else:
+                    json_str = content
+            
+            # Parse the JSON
+            function_call = json.loads(json_str)
+            return function_call
+        except json.JSONDecodeError:
+            raise Exception("Could not parse JSON from LLM response")
+    except Exception as e:
+        raise Exception(f"Error calling API: {str(e)}")
+
+def format_summary_for_display(results, language="English"):
+    output = []
+    
+    if language == "Uzbek":
+        segment_header = "QISM"
+        key_concepts_header = "ASOSIY TUSHUNCHALAR"
+        summary_header = "QISQACHA MAZMUN"
+    elif language == "Russian":
+        segment_header = "СЕГМЕНТ"
+        key_concepts_header = "КЛЮЧЕВЫЕ ПОНЯТИЯ"
+        summary_header = "КРАТКОЕ СОДЕРЖАНИЕ"
+    else:
+        segment_header = "SEGMENT"
+        key_concepts_header = "KEY CONCEPTS"
+        summary_header = "SUMMARY"
+    
+    segments = results.get("segments", [])
+    for i, segment in enumerate(segments):
+        topic = segment["topic_name"]
+        segment_num = i + 1 
+        output.append(f"\n\n{'='*40}")
+        output.append(f"{segment_header} {segment_num}: {topic}")
+        output.append(f"{'='*40}\n")
+        output.append(f"{key_concepts_header}:")
+        for concept in segment["key_concepts"]:
+            output.append(f"• {concept}")
+        output.append(f"\n{summary_header}:")
+        output.append(segment["summary"])
+    
+    return "\n".join(output)
+
+def format_quiz_for_display(results, language="English"):
+    output = []
+    
+    if language == "Uzbek":
+        quiz_questions_header = "TEST SAVOLLARI"
+    elif language == "Russian":
+        quiz_questions_header = "ТЕСТОВЫЕ ВОПРОСЫ"
+    else:
+        quiz_questions_header = "QUIZ QUESTIONS"
+    
+    output.append(f"{'='*40}")
+    output.append(f"{quiz_questions_header}")
+    output.append(f"{'='*40}\n")
+    
+    quiz_questions = results.get("quiz_questions", [])
+    for i, q in enumerate(quiz_questions):
+        output.append(f"\n{i+1}. {q['question']}")
+        for j, option in enumerate(q['options']):
+            letter = chr(97 + j).upper()
+            correct_marker = " ✓" if option["correct"] else ""
+            output.append(f"   {letter}. {option['text']}{correct_marker}")
+    
+    return "\n".join(output)
+
+def analyze_document(text, gemini_api_key, language, content_type="summary"):
+    try:
+        start_time = time.time()
+        text_parts = split_text_by_tokens(text)
+
+        input_tokens = 0        
+        output_tokens = 0
+        
+        if content_type == "summary":
+            all_results = {"segments": []}
+            segment_counter = 1
+            
+            for part in text_parts:
+                actual_prompt = SUMMARY_PROMPT_TEMPLATE.format(text=part)
+                prompt_tokens = len(tokenizer.encode(actual_prompt))
+                input_tokens += prompt_tokens
+                
+                analysis = generate_with_gemini(part, gemini_api_key, language, "summary")
+                
+                if "segments" in analysis:
+                    for segment in analysis["segments"]:
+                        segment["segment_number"] = segment_counter
+                        all_results["segments"].append(segment)
+                        segment_counter += 1
+            
+            formatted_output = format_summary_for_display(all_results, language)
+            
+        else:  # Quiz generation
+            all_results = {"quiz_questions": []}
+            
+            for part in text_parts:
+                actual_prompt = QUIZ_PROMPT_TEMPLATE.format(text=part)
+                prompt_tokens = len(tokenizer.encode(actual_prompt))
+                input_tokens += prompt_tokens
+                
+                analysis = generate_with_gemini(part, gemini_api_key, language, "quiz")
+                
+                if "quiz_questions" in analysis:
+                    remaining_slots = 10 - len(all_results["quiz_questions"])
+                    if remaining_slots > 0:
+                        questions_to_add = analysis["quiz_questions"][:remaining_slots]
+                        all_results["quiz_questions"].extend(questions_to_add)
+            
+            formatted_output = format_quiz_for_display(all_results, language)
+        
+        end_time = time.time()
+        total_time = end_time - start_time
+        
+        output_tokens = len(tokenizer.encode(formatted_output))
+        token_info = f"Input tokens: {input_tokens}\nOutput tokens: {output_tokens}\nTotal tokens: {input_tokens + output_tokens}\n"
+        formatted_text = f"Total Processing time: {total_time:.2f}s\n{token_info}\n" + formatted_output
+
+        json_path = tempfile.mktemp(suffix='.json')
+        with open(json_path, 'w', encoding='utf-8') as json_file:
+            json.dump(all_results, json_file, indent=2)
+        
+        txt_path = tempfile.mktemp(suffix='.txt')
+        with open(txt_path, 'w', encoding='utf-8') as txt_file:
+            txt_file.write(formatted_text)
+            
+        return formatted_text, json_path, txt_path
+    except Exception as e:
+        error_message = f"Error processing document: {str(e)}"
+        return error_message, None, None

src/quiz_processing_1.py

@@ -0,0 +1,297 @@
+import os
+import re
+import json
+import time
+import gradio as gr
+import tempfile
+from typing import Dict, Any, List, Optional
+from transformers import AutoTokenizer
+from sentence_transformers import SentenceTransformer
+from pydantic import BaseModel, Field
+from anthropic import Anthropic
+from huggingface_hub import login
+
+CLAUDE_MODEL = "claude-3-5-sonnet-20241022"
+OPENAI_MODEL = "gpt-4o"
+GEMINI_MODEL = "gemini-2.0-flash"
+
+DEFAULT_TEMPERATURE = 0.7
+
+TOKENIZER_MODEL = "answerdotai/ModernBERT-base"
+SENTENCE_TRANSFORMER_MODEL = "all-MiniLM-L6-v2"
+
+class CourseInfo(BaseModel):
+    course_name: str = Field(description="Name of the course")
+    section_name: str = Field(description="Name of the course section")
+    lesson_name: str = Field(description="Name of the lesson")
+
+class QuizOption(BaseModel):
+    text: str = Field(description="The text of the answer option")
+    correct: bool = Field(description="Whether this option is correct")
+
+class QuizQuestion(BaseModel):
+    question: str = Field(description="The text of the quiz question")
+    options: List[QuizOption] = Field(description="List of answer options")
+
+class Segment(BaseModel):
+    segment_number: int = Field(description="The segment number")
+    topic_name: str = Field(description="Unique and specific topic name that clearly differentiates it from other segments")
+    key_concepts: List[str] = Field(description="3-5 key concepts discussed in the segment")
+    summary: str = Field(description="Brief summary of the segment (3-5 sentences)")
+    quiz_questions: List[QuizQuestion] = Field(description="5 quiz questions based on the segment content")
+
+class TextSegmentAnalysis(BaseModel):
+    course_info: CourseInfo = Field(description="Information about the course")
+    segments: List[Segment] = Field(description="List of text segments with analysis")
+
+
+hf_token = os.environ.get('HF_TOKEN', None)
+login(token=hf_token)
+
+tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_MODEL)
+sentence_model = SentenceTransformer(SENTENCE_TRANSFORMER_MODEL)
+
+# System prompt
+system_prompt = """You are an expert educational content analyzer. Your task is to analyze text content, 
+identify distinct segments, and create high-quality educational quiz questions for each segment."""
+
+def clean_text(text):
+    text = re.sub(r'\[speaker_\d+\]', '', text)
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+def split_text_by_tokens(text, max_tokens=8000):
+    text = clean_text(text)
+    tokens = tokenizer.encode(text)
+    
+    if len(tokens) <= max_tokens:
+        return [text]
+    
+    split_point = len(tokens) // 2
+    
+    sentences = re.split(r'(?<=[.!?])\s+', text)
+    
+    first_half = []
+    second_half = []
+    
+    current_tokens = 0
+    for sentence in sentences:
+        sentence_tokens = len(tokenizer.encode(sentence))
+        
+        if current_tokens + sentence_tokens <= split_point:
+            first_half.append(sentence)
+            current_tokens += sentence_tokens
+        else:
+            second_half.append(sentence)
+    
+    return [" ".join(first_half), " ".join(second_half)]
+
+
+
+def generate_with_claude(text, api_key, course_name="", section_name="", lesson_name=""):
+    from prompts import SYSTEM_PROMPT, ANALYSIS_PROMPT_TEMPLATE_CLAUDE
+
+    client = Anthropic(api_key=api_key)
+    
+    segment_analysis_schema = TextSegmentAnalysis.model_json_schema()
+    
+    tools = [
+        {
+            "name": "build_segment_analysis",
+            "description": "Build the text segment analysis with quiz questions",
+            "input_schema": segment_analysis_schema
+        }
+    ]
+    
+    system_prompt = """You are a helpful assistant specialized in text analysis and educational content creation. 
+    You analyze texts to identify distinct segments, create summaries, and generate quiz questions."""
+    
+    prompt =     prompt = ANALYSIS_PROMPT_TEMPLATE_CLAUDE.format(
+        course_name=course_name,
+        section_name=section_name,
+        lesson_name=lesson_name,
+        text=text
+    )
+
+    try:
+        response = client.messages.create(
+            model=CLAUDE_MODEL,
+            max_tokens=8192,
+            temperature=DEFAULT_TEMPERATURE,
+            system=system_prompt,
+            messages=[
+                {
+                    "role": "user",
+                    "content": prompt
+                }
+            ],
+            tools=tools,
+            tool_choice={"type": "tool", "name": "build_segment_analysis"}
+        )
+        
+        # Extract the tool call content
+        if response.content and len(response.content) > 0 and hasattr(response.content[0], 'input'):
+            function_call = response.content[0].input
+            return function_call
+        else:
+            raise Exception("No valid tool call found in the response")
+    except Exception as e:
+        raise Exception(f"Error calling Anthropic API: {str(e)}")
+
+
+
+
+def get_llm_by_api_key(api_key):
+    if api_key.startswith("sk-ant-"):  # Claude API key format
+        from langchain_anthropic import ChatAnthropic
+        return ChatAnthropic(
+            anthropic_api_key=api_key,
+            model_name=CLAUDE_MODEL,
+            temperature=DEFAULT_TEMPERATURE,
+            max_retries=3
+        )
+    elif api_key.startswith("sk-"):  # OpenAI API key format
+        from langchain_openai import ChatOpenAI
+        return ChatOpenAI(
+            openai_api_key=api_key,
+            model_name=OPENAI_MODEL,
+            temperature=DEFAULT_TEMPERATURE,
+            max_retries=3
+        )
+    else:  # Default to Gemini
+        from langchain_google_genai import ChatGoogleGenerativeAI
+        os.environ["GOOGLE_API_KEY"] = api_key
+        return ChatGoogleGenerativeAI(
+            model=GEMINI_MODEL,
+            temperature=DEFAULT_TEMPERATURE,
+            max_retries=3
+        )
+
+def segment_and_analyze_text(text: str, api_key: str, course_name="", section_name="", lesson_name="") -> Dict[str, Any]:
+    from prompts import SYSTEM_PROMPT, ANALYSIS_PROMPT_TEMPLATE_GEMINI
+    if api_key.startswith("sk-ant-"):
+        return generate_with_claude(text, api_key, course_name, section_name, lesson_name)
+    
+    # For other models, use LangChain
+    llm = get_llm_by_api_key(api_key)
+    
+    prompt = ANALYSIS_PROMPT_TEMPLATE_GEMINI.format(
+        course_name=course_name,
+        section_name=section_name,
+        lesson_name=lesson_name,
+        text=text
+    )
+
+    try:
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": prompt}
+        ]
+        
+        response = llm.invoke(messages)
+        
+        try:
+            content = response.content
+            json_match = re.search(r'```json\s*([\s\S]*?)\s*```', content)
+            
+            if json_match:
+                json_str = json_match.group(1)
+            else:
+                json_match = re.search(r'(\{[\s\S]*\})', content)
+                if json_match:
+                    json_str = json_match.group(1)
+                else:
+                    json_str = content
+            
+            # Parse the JSON
+            function_call = json.loads(json_str)
+            return function_call
+        except json.JSONDecodeError:
+            raise Exception("Could not parse JSON from LLM response")
+    except Exception as e:
+        raise Exception(f"Error calling API: {str(e)}")
+
+def format_quiz_for_display(results):
+    output = []
+    
+    if "course_info" in results:
+        course_info = results["course_info"]
+        output.append(f"{'='*40}")
+        output.append(f"COURSE: {course_info.get('course_name', 'N/A')}")
+        output.append(f"SECTION: {course_info.get('section_name', 'N/A')}")
+        output.append(f"LESSON: {course_info.get('lesson_name', 'N/A')}")
+        output.append(f"{'='*40}\n")
+    
+    segments = results.get("segments", [])
+    for i, segment in enumerate(segments):
+        topic = segment["topic_name"]
+        segment_num = i + 1 
+        output.append(f"\n\n{'='*40}")
+        output.append(f"SEGMENT {segment_num}: {topic}")
+        output.append(f"{'='*40}\n")
+        output.append("KEY CONCEPTS:")
+        for concept in segment["key_concepts"]:
+            output.append(f"• {concept}")
+        output.append("\nSUMMARY:")
+        output.append(segment["summary"])
+        output.append("\nQUIZ QUESTIONS:")
+        for i, q in enumerate(segment["quiz_questions"]):
+            output.append(f"\n{i+1}. {q['question']}")
+            for j, option in enumerate(q['options']):
+                letter = chr(97 + j).upper()
+                correct_marker = " ✓" if option["correct"] else ""
+                output.append(f"   {letter}. {option['text']}{correct_marker}")
+    return "\n".join(output)
+
+def analyze_document(text, api_key, course_name, section_name, lesson_name):
+    try:
+        start_time = time.time()
+        text_parts = split_text_by_tokens(text)
+        
+        all_results = {
+            "course_info": {
+                "course_name": course_name,
+                "section_name": section_name,
+                "lesson_name": lesson_name
+            },
+            "segments": []
+        }
+        segment_counter = 1
+        
+        # Process each part of the text
+        for part in text_parts:
+            analysis = segment_and_analyze_text(
+                part, 
+                api_key,
+                course_name=course_name, 
+                section_name=section_name, 
+                lesson_name=lesson_name
+            )
+            
+            if "segments" in analysis:
+                for segment in analysis["segments"]:
+                    segment["segment_number"] = segment_counter
+                    all_results["segments"].append(segment)
+                    segment_counter += 1
+        
+        end_time = time.time()
+        total_time = end_time - start_time
+        print(f"Total quiz processing time: {total_time}s")
+
+        # Format the results for display
+        formatted_text = format_quiz_for_display(all_results)
+        # formatted_text = f"Total processing time: {total_time:.2f} seconds\n\n" + formatted_text
+        
+        # Create temporary files for JSON and text output
+        json_path = tempfile.mktemp(suffix='.json')
+        with open(json_path, 'w', encoding='utf-8') as json_file:
+            json.dump(all_results, json_file, indent=2)
+        
+        txt_path = tempfile.mktemp(suffix='.txt')
+        with open(txt_path, 'w', encoding='utf-8') as txt_file:
+            txt_file.write(formatted_text)
+            
+        return formatted_text, json_path, txt_path
+    except Exception as e:
+        error_message = f"Error processing document: {str(e)}"
+        return error_message, None, None

src/video_processing.py

@@ -0,0 +1,96 @@
+import os
+import requests
+import uuid
+import subprocess
+import time
+
+def extract_audio_from_video(video_path, output_format="mp3"):
+    if not video_path:
+        return None
+    
+    output_path = f"audio_{uuid.uuid4().hex[:6]}.{output_format}"
+    
+    try:
+        cmd = [
+            "ffmpeg",
+            "-i", video_path,
+            "-vn",
+            "-c:a", "libmp3lame" if output_format == "mp3" else output_format,
+            "-q:a", "9",
+            "-ac", "1",
+            "-ar", "12000",
+            "-y", output_path
+        ]
+        
+        subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        
+        if os.path.exists(output_path):
+            return output_path
+        else:
+            raise Exception("Audio extraction failed")
+    except Exception as e:
+        raise Exception(f"Error extracting audio: {str(e)}")
+
+def transcribe_audio(audio_path, api_key, model_id="scribe_v1"):
+    if not api_key:
+        raise Exception("API key required")
+    
+    url = "https://api.elevenlabs.io/v1/speech-to-text"
+    headers = {"xi-api-key": api_key}
+    
+    try:
+        with open(audio_path, "rb") as file:
+            response = requests.post(
+                url,
+                headers=headers,
+                files={"file": file, "model_id": (None, model_id)},
+                timeout=120
+            )
+        
+        if response.status_code == 200:
+            result = response.json()
+            transcript_text = result.get("text", "")
+            
+            # Save transcript to file
+            transcript_file = f"transcript_{uuid.uuid4().hex[:6]}.txt"
+            with open(transcript_file, "w", encoding="utf-8") as f:
+                f.write(transcript_text)
+            
+            return transcript_text, transcript_file, "Transcription completed successfully"
+        else:
+            raise Exception(f"API error: {response.status_code}")
+    except Exception as e:
+        raise Exception(f"Transcription failed: {str(e)}")
+
+def process_video_file(video_path, audio_format, elevenlabs_api_key, model_id, gemini_api_key, language, content_type):
+    try:
+        print("Starting video processing...")
+        start = time.time()
+        
+        audio_path = extract_audio_from_video(video_path, audio_format)
+        print(f"Audio extracted in {time.time() - start:.2f}s. Transcribing...")
+        
+        transcription, transcript_path, transcription_status = transcribe_audio(
+            audio_path, 
+            elevenlabs_api_key, 
+            model_id
+        )
+        
+        if not transcription:
+            return audio_path, "Audio extracted, but transcription failed", None, transcription_status, None, None, None
+        
+        print(f"Transcription completed in {time.time() - start:.2f}s. Analyzing content...")
+        
+        # Generate summary or quiz from transcription
+        formatted_output, json_path, txt_path = analyze_document(
+            transcription, 
+            gemini_api_key, 
+            language, 
+            content_type
+        )
+        
+        print(f"Total processing time: {time.time() - start:.2f}s")
+        return audio_path, "Processing completed successfully", transcript_path, transcription_status, formatted_output, txt_path, json_path
+    except Exception as e:
+        error_message = f"Error processing video: {str(e)}"
+        return None, error_message, None, error_message, error_message, None, None