Merge pull request #2 from 23f3003322/dev

.gitignore

@@ -50,4 +50,4 @@ orchestrator.md
 questions.md
 task_processor.md
 unified.md
-
+audio_processor.md

app/services/answer_generator.py

@@ -5,6 +5,7 @@ from app.core.logging import get_logger
 from app.core.exceptions import AnswerGenerationError
 from app.models.answer import AnswerResult
 from app.models.analysis import QuestionAnalysis
+from app.services.audio_processor import AudioProcessor
 logger = get_logger(__name__)
 
 
@@ -21,6 +22,7 @@ class AnswerGenerator:
         """
         self.llm_client = llm_client
         self._generator_agent = None
+        self.audio_processor = AudioProcessor() 
     
     async def initialize(self):
         """Initialize LLM agent for answer generation"""
@@ -63,6 +65,35 @@ class AnswerGenerator:
         logger.info(f"💡 Generating answer for {analysis.question_type}...")
         
         try:
+            if analysis.question_type == 'audio_transcription':
+                logger.info("🎤 Audio transcription task detected")
+                
+                # Find audio file
+                audio_file = next(
+                    (f for f in downloaded_files 
+                     if f['type'] in ['.opus', '.mp3', '.wav', '.m4a', '.ogg']),
+                    None
+                )
+                
+                if not audio_file:
+                    raise AnswerGenerationError(
+                        "Audio file not found. Expected .opus, .mp3, or .wav file."
+                    )
+                
+                logger.info(f"  Found audio file: {audio_file['filename']}")
+                
+                # Transcribe audio
+                answer = await self.audio_processor.transcribe_audio(
+                    audio_file_path=audio_file['local_path'],
+                    language='en',  # English for Q5
+                    lowercase=True  # Q5 requires lowercase
+                )
+                
+                logger.info(f"✓ Audio transcribed successfully")
+                logger.info(f"  Answer: {answer}")
+                
+                return answer
+            
             # Step 1: Build comprehensive context for LLM
             context = self._build_generation_context(
                 analysis=analysis,

app/services/audio_processor.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from typing import Optional, List
+from pathlib import Path
+import base64
+import httpx
+
+from app.core.logging import get_logger
+from app.core.exceptions import AnswerGenerationError
+
+logger = get_logger(__name__)
+
+
+class AudioProcessor:
+    """
+    Transcribe audio using OpenRouter (via aipipe) by sending audio to an
+    audio-capable model and asking it to transcribe.
+
+    This is designed for Project2 Q5: return lowercase transcription including 3-digit code.
+    """
+
+    def __init__(
+        self,
+        aipipe_token: Optional[str] = None,
+        base_url: str = "https://aipipe.org/openrouter/v1",
+        # Best default from your available list for transcription:
+        primary_model: str = "mistralai/voxtral-small-24b-2507",
+        # Fallbacks (all appear in your /models list):
+        fallback_models: Optional[List[str]] = None,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.primary_model = primary_model
+        self.fallback_models = fallback_models or [
+            "google/gemini-2.5-pro",
+            "google/gemini-2.5-flash",
+            "google/gemini-2.5-flash-lite",
+        ]
+
+        if aipipe_token is None:
+            import os
+            aipipe_token = os.getenv("AIPIPE_TOKEN")
+
+        if not aipipe_token:
+            raise ValueError("AIPIPE_TOKEN not found in environment or constructor")
+
+        self.aipipe_token = aipipe_token
+        logger.info(
+            "✓ AudioProcessor(OpenRouter) initialized "
+            f"primary_model={self.primary_model}"
+        )
+
+    def _models_to_try(self) -> List[str]:
+        # Keep order: primary first, then fallbacks
+        models = [self.primary_model]
+        for m in self.fallback_models:
+            if m not in models:
+                models.append(m)
+        return models
+
+    async def transcribe_audio(
+        self,
+        audio_file_path: str,
+        language: Optional[str] = "en",
+        lowercase: bool = True,
+    ) -> str:
+        audio_path = Path(audio_file_path)
+        if not audio_path.exists():
+            raise AnswerGenerationError(f"Audio file not found: {audio_file_path}")
+
+        audio_bytes = audio_path.read_bytes()
+        audio_b64 = base64.b64encode(audio_bytes).decode("utf-8")
+
+        # Most of your quiz files are .opus
+        fmt = "opus" if audio_path.suffix.lower() == ".opus" else "wav"
+
+        url = f"{self.base_url}/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {self.aipipe_token}",
+            "Content-Type": "application/json",
+        }
+
+        prompt = (
+            "Task: Transcribe the provided audio exactly.\n"
+            "Output rules:\n"
+            "- Return ONLY the transcription text.\n"
+            "- Lowercase only.\n"
+            "- Include the 3-digit number exactly.\n"
+            "- Do not add explanations.\n"
+            "- Do not refuse.\n"
+        )
+        if language:
+            prompt += f"Language hint: {language}.\n"
+
+        last_err = None
+
+        for model in self._models_to_try():
+            payload = {
+                "model": model,
+                "temperature": 0,
+                # Strongly encourage plain text output
+                "response_format": {"type": "text"},
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": prompt},
+                            {
+                                "type": "input_audio",
+                                "input_audio": {
+                                    "data": audio_b64,
+                                    "format": fmt,
+                                },
+                            },
+                        ],
+                    }
+                ],
+            }
+
+            logger.info(f"🎤 Transcribing via OpenRouter: model={model}")
+            async with httpx.AsyncClient(timeout=180.0) as client:
+                resp = await client.post(url, headers=headers, json=payload)
+
+            if resp.status_code != 200:
+                last_err = f"{resp.status_code} - {resp.text}"
+                logger.warning(f"Model failed: {model} -> {last_err}")
+                continue
+
+            data = resp.json()
+            try:
+                text = data["choices"][0]["message"]["content"]
+            except Exception:
+                last_err = f"Unexpected response shape: {data}"
+                logger.warning(f"Model returned unexpected shape: {model}")
+                continue
+
+            transcription = (text or "").strip()
+            transcription = " ".join(transcription.split())
+            if lowercase:
+                transcription = transcription.lower()
+
+            # Guard against refusals
+            low = transcription.lower()
+            if "can't process audio" in low or "cannot process audio" in low or "i can't" in low:
+                last_err = f"Model refused audio: {model} -> {transcription}"
+                logger.warning(last_err)
+                continue
+
+            # Success
+            logger.info(f"✓ Transcription success with {model}: '{transcription}'")
+            return transcription
+
+        raise AnswerGenerationError(
+            "All OpenRouter audio-capable models failed for transcription. "
+            f"Last error: {last_err}"
+        )

app/services/task_fetcher.py

@@ -4,6 +4,9 @@ Fetches and extracts task descriptions from URLs
 """
 
 import httpx
+from pathlib import Path
+import tempfile
+from urllib.parse import urljoin
 import json
 import re
 from typing import Optional, Dict, Any, List
@@ -117,53 +120,100 @@ class TaskFetcher:
         }
 
         return result
-        # analysis = await self._analyze_content_with_llm(
-        #     task_description=content['task_description'],
-        #     raw_content=content['raw_content'],
-        #     url=url,
-        #     base_url=base_url
-        # )
-        
-        # # Merge content + analysis
-        # result = {
-        #     **content,
-        #     'is_redirect': analysis.is_redirect,
-        #     'question_url': analysis.question_url,
-        #     'submission_url': analysis.submission_url,
-        #     'instructions': self._format_instructions(analysis.instructions),
-        #     'overall_goal': analysis.overall_goal,
-        #     'complexity': analysis.complexity,
-        #     'llm_analysis': {
-        #         'redirect_reasoning': analysis.redirect_reasoning,
-        #         'submission_reasoning': analysis.submission_reasoning,
-        #         'confidence': analysis.confidence,
-        #     }
-        # }
-        
-        # # Resolve relative submission URL if needed
-        # if analysis.submission_url and analysis.submission_url_is_relative:
-        #     absolute = str(httpx.URL(base_url).join(analysis.submission_url))
-        #     logger.info(f"✓ Resolved relative submission URL: {analysis.submission_url} → {absolute}")
-        #     result['submission_url'] = absolute
-        
-        # # Resolve relative question URL if needed
-        # if analysis.question_url and analysis.question_url.startswith('/'):
-        #     absolute_q = str(httpx.URL(base_url).join(analysis.question_url))
-        #     logger.info(f"✓ Resolved relative question URL: {analysis.question_url} → {absolute_q}")
-        #     result['question_url'] = absolute_q
-        
-        # logger.info("✅ Analysis complete:")
-        # logger.info(f"   Is Redirect: {result['is_redirect']}")
-        # logger.info(f"   Submission URL: {result['submission_url']}")
-        # logger.info(f"   Instructions: {len(result['instructions'])} steps")
-        # logger.info(f"   Complexity: {result['complexity']}")
-        
-        # return result
-
-    # ======================================================================
-    # FETCHING WITH FALLBACK TO DYNAMIC SCRAPER
-    # ======================================================================
-
+       
+    async def _download_files(
+        self,
+        file_links: List[Dict[str, str]],
+        base_url: str,
+        user_email: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Download files referenced in question.
+        
+        Args:
+            file_links: List of dicts with 'href' and 'text'
+                Example: [{'href': '/project2/messy.csv', 'text': 'messy.csv'}]
+            base_url: Base URL to construct absolute URLs
+            user_email: User email for personalized URLs
+        
+        Returns:
+            List of dicts with file info:
+                - url: Original URL
+                - local_path: Path to downloaded file
+                - filename: Extracted filename
+                - size: File size in bytes
+                - type: File extension (.csv, .json, etc.)
+        """
+        if not file_links:
+            return []
+        
+        downloaded_files = []
+        
+        # Create download directory
+        download_dir = Path(tempfile.gettempdir()) / "quiz_files"
+        download_dir.mkdir(exist_ok=True)
+        
+        logger.info(f"📥 Downloading {len(file_links)} files to {download_dir}")
+        
+        for link in file_links:
+            href = link['href']
+            
+            try:
+                # Handle personalized URLs
+                # Example: "/project2/uv.json?email=<your email>"
+                if '<your email>' in href and user_email:
+                    href = href.replace('<your email>', user_email)
+                    logger.debug(f"Personalized URL: {href}")
+                
+                # Construct absolute URL
+                full_url = urljoin(base_url, href)
+                
+                # Extract filename
+                # "/project2/messy.csv" -> "messy.csv"
+                # "/project2/[email protected]" -> "data.json"
+                filename = Path(href.split('?')[0]).name
+                local_path = download_dir / filename
+                
+                # Download file
+                logger.info(f"  Downloading: {filename} from {full_url}")
+                
+                # Use existing httpx client if available, or create new one
+                if hasattr(self, 'client') and self.client:
+                    response = await self.client.get(full_url, timeout=60.0)
+                else:
+                    async with httpx.AsyncClient() as client:
+                        response = await client.get(full_url, timeout=60.0)
+                
+                response.raise_for_status()
+                
+                # Save to disk
+                with open(local_path, 'wb') as f:
+                    f.write(response.content)
+                
+                # Get file info
+                file_info = {
+                    'url': full_url,
+                    'local_path': str(local_path),
+                    'filename': filename,
+                    'size': len(response.content),
+                    'type': local_path.suffix  # .csv, .json, .png, etc.
+                }
+                
+                downloaded_files.append(file_info)
+                logger.info(f"  ✓ Downloaded: {filename} ({file_info['size']} bytes)")
+                
+            except httpx.HTTPStatusError as e:
+                logger.error(f"  ✗ HTTP error downloading {href}: {e.response.status_code}")
+                # Continue with other files
+                
+            except Exception as e:
+                logger.error(f"  ✗ Failed to download {href}: {e}")
+                # Continue with other files
+        
+        logger.info(f"✓ Downloaded {len(downloaded_files)}/{len(file_links)} files")
+        
+        return downloaded_files
+    
     async def _fetch_content(self, url: str) -> Dict[str, Any]:
         """
         Fetch content from URL.