suggest duration by AI

backend/integrations/ai_integration/ai_generator_interface.py

@@ -54,4 +54,20 @@ class AIGeneratorInterface(ABC):
                 'correct': bool  # Whether the answer is correct
             }
         """
+        pass
+
+    @abstractmethod
+    def estimate_duration(
+        self,
+        prompt: str
+    ) -> str:
+        """
+        Estimate the duration for an assessment based on a prompt.
+
+        Args:
+            prompt: A detailed prompt describing the assessment
+
+        Returns:
+            String response from the AI containing the estimated duration
+        """
         pass

backend/integrations/ai_integration/anthropic_generator.py

@@ -36,4 +36,21 @@ class AnthropicGenerator(AIGeneratorInterface):
         """
         # In a real implementation, this would call the Anthropic API
         # For now, we'll raise an exception indicating it's not implemented
-        raise NotImplementedError("Anthropic answer scoring not yet implemented")
+        raise NotImplementedError("Anthropic answer scoring not yet implemented")
+
+    def estimate_duration(
+        self,
+        prompt: str
+    ) -> str:
+        """
+        Estimate the duration for an assessment based on a prompt.
+
+        Args:
+            prompt: A detailed prompt describing the assessment
+
+        Returns:
+            String response from the AI containing the estimated duration
+        """
+        # In a real implementation, this would call the Anthropic API
+        # For now, we'll raise an exception indicating it's not implemented
+        raise NotImplementedError("Anthropic duration estimation not yet implemented")

backend/integrations/ai_integration/google_ai_generator.py

@@ -36,4 +36,21 @@ class GoogleAIGenerator(AIGeneratorInterface):
         """
         # In a real implementation, this would call the Google AI API
         # For now, we'll raise an exception indicating it's not implemented
-        raise NotImplementedError("Google AI answer scoring not yet implemented")
+        raise NotImplementedError("Google AI answer scoring not yet implemented")
+
+    def estimate_duration(
+        self,
+        prompt: str
+    ) -> str:
+        """
+        Estimate the duration for an assessment based on a prompt.
+
+        Args:
+            prompt: A detailed prompt describing the assessment
+
+        Returns:
+            String response from the AI containing the estimated duration
+        """
+        # In a real implementation, this would call the Google AI API
+        # For now, we'll raise an exception indicating it's not implemented
+        raise NotImplementedError("Google AI duration estimation not yet implemented")

backend/integrations/ai_integration/mistral_generator.py

@@ -278,3 +278,30 @@ Return ONLY the JSON array.
             assessment_questions.append(question)
 
         return assessment_questions
+
+    def estimate_duration(
+        self,
+        prompt: str
+    ) -> str:
+        """
+        Estimate the duration for an assessment based on a prompt.
+
+        Args:
+            prompt: A detailed prompt describing the assessment
+
+        Returns:
+            String response from the AI containing the estimated duration
+        """
+        messages = [
+            {"role": "system", "content": "You estimate assessment durations. Respond with only a number representing minutes."},
+            {"role": "user", "content": prompt},
+        ]
+
+        response = self.client.chat.complete(
+            model="mistral-small-latest",
+            messages=messages,
+            temperature=0.2,
+        )
+
+        content = response.choices[0].message.content
+        return content

backend/integrations/ai_integration/mock_ai_generator.py

@@ -375,4 +375,32 @@ class MockAIGenerator(AIGeneratorInterface):
             score += 0.2
 
         # Cap the score at 1.0
-        return min(score, 1.0)
+        return min(score, 1.0)
+
+    def estimate_duration(
+        self,
+        prompt: str
+    ) -> str:
+        """
+        Estimate the duration for an assessment based on a prompt.
+
+        Args:
+            prompt: A detailed prompt describing the assessment
+
+        Returns:
+            String response from the AI containing the estimated duration
+        """
+        # For the mock implementation, we'll return a simple response with a number
+        # based on the length of the prompt and keywords
+        import random
+        
+        # Count the number of questions mentioned in the prompt
+        question_count = prompt.count("Question ")  # Count occurrences of "Question "
+        
+        # Estimate duration based on question count (3 minutes per question, with some randomness)
+        estimated_minutes = max(5, question_count * 3 + random.randint(-2, 5))
+        
+        # Ensure it's within reasonable bounds
+        estimated_minutes = min(180, max(5, estimated_minutes))
+        
+        return f"{estimated_minutes} minutes"

backend/integrations/ai_integration/openai_generator.py

@@ -36,4 +36,21 @@ class OpenAIGenerator(AIGeneratorInterface):
         """
         # In a real implementation, this would call the OpenAI API
         # For now, we'll raise an exception indicating it's not implemented
-        raise NotImplementedError("OpenAI answer scoring not yet implemented")
+        raise NotImplementedError("OpenAI answer scoring not yet implemented")
+
+    def estimate_duration(
+        self,
+        prompt: str
+    ) -> str:
+        """
+        Estimate the duration for an assessment based on a prompt.
+
+        Args:
+            prompt: A detailed prompt describing the assessment
+
+        Returns:
+            String response from the AI containing the estimated duration
+        """
+        # In a real implementation, this would call the OpenAI API
+        # For now, we'll raise an exception indicating it's not implemented
+        raise NotImplementedError("OpenAI duration estimation not yet implemented")

backend/schemas/assessment.py

@@ -25,14 +25,12 @@ class AssessmentBase(BaseSchema):
 
 class AssessmentCreate(BaseModel):
     title: str = Field(..., min_length=1, max_length=200)
-    duration: Optional[int] = Field(None, ge=1)  # Duration in seconds, if provided should be positive
     passing_score: int = Field(..., ge=20, le=80)  # range 20-80
     questions_types: List[QuestionType]  # array of enum(choose_one, choose_many, text_based)
     additional_note: Optional[str] = Field(None, max_length=500)
 
 class AssessmentUpdate(BaseModel):
     title: Optional[str] = Field(None, min_length=1, max_length=200)
-    duration: Optional[int] = Field(None, ge=1)  # Duration in seconds, if provided should be positive
     passing_score: Optional[int] = Field(None, ge=20, le=80)  # range 20-80
     questions: Optional[List[AssessmentQuestion]] = None
     active: Optional[bool] = None

backend/services/__init__.py

@@ -42,6 +42,10 @@ from .application_service import (
     calculate_application_score
 )
 
+from .ai_service import (
+    estimate_assessment_duration
+)
+
 __all__ = [
     "get_user",
     "get_user_by_email",
@@ -71,5 +75,6 @@ __all__ = [
     "create_application",
     "update_application",
     "delete_application",
-    "calculate_application_score"
+    "calculate_application_score",
+    "estimate_assessment_duration"
 ]

backend/services/ai_service.py

@@ -1,3 +1,4 @@
+import re
 from typing import List, Dict, Any
 from schemas.assessment import AssessmentQuestion
 from schemas.application import ApplicationAnswerWithQuestion
@@ -76,4 +77,73 @@ def score_answer(question: AssessmentQuestion, answer_text: str, selected_option
     )
 
     logger.info(f"Scored answer with score: {score_result['score']}, correct: {score_result['correct']}")
-    return score_result
+    return score_result
+
+def estimate_assessment_duration(title: str, job_info: dict, questions: List[AssessmentQuestion], additional_note: str = None, provider=None) -> int:
+    """
+    Estimate the duration needed for an assessment based on its details and questions.
+
+    Args:
+        title: The title of the assessment
+        job_info: Information about the job the assessment is for
+        questions: List of questions in the assessment
+        additional_note: Additional information about the assessment
+        provider: The AI provider to use (defaults to the default provider)
+
+    Returns:
+        Estimated duration in minutes
+    """
+    logger.info(f"Estimating duration for assessment: '{title}' with {len(questions)} questions")
+
+    # Use the default provider if none is specified
+    if provider is None:
+        provider = DEFAULT_PROVIDER
+
+    # Get the AI generator from the factory
+    ai_generator = AIGeneratorFactory.create_generator(provider)
+
+    # Prepare the prompt for the AI
+    prompt = f"""
+    Based on the following assessment details, estimate how many minutes a candidate would need to complete this assessment.
+    Consider the complexity of the questions and the job requirements.
+    
+    Assessment Title: {title}
+    
+    Job Information:
+    - Title: {job_info.get('title', 'N/A')}
+    - Seniority: {job_info.get('seniority', 'N/A')}
+    - Description: {job_info.get('description', 'N/A')}
+    - Skill Categories: {', '.join(job_info.get('skill_categories', []))}
+    
+    Questions Count: {len(questions)}
+    """
+
+    # Add question details to the prompt
+    for i, question in enumerate(questions[:5]):  # Limit to first 5 questions to avoid overly long prompts
+        prompt += f"\nQuestion {i+1} ({question.type}): {question.text[:100]}..."
+        if question.type == 'text_based':
+            prompt += " (Text-based question requiring written response)"
+        elif question.type in ['choose_one', 'choose_many']:
+            prompt += f" (Multiple choice with {len(question.options)} options)"
+
+    if additional_note:
+        prompt += f"\nAdditional Notes: {additional_note}"
+
+    prompt += "\n\nPlease provide only a number representing the estimated duration in minutes."
+
+    # Get the AI's estimation
+    duration_estimate = ai_generator.estimate_duration(prompt)
+
+    # Extract the first number from the response using regex
+    duration_match = re.search(r'\d+', duration_estimate)
+    if duration_match:
+        duration_minutes = int(duration_match.group())
+        # Ensure the duration is within reasonable bounds (1-180 minutes)
+        duration_minutes = max(1, min(180, duration_minutes))
+        logger.info(f"Estimated duration for assessment '{title}': {duration_minutes} minutes")
+        return duration_minutes
+    else:
+        # If no number is found in the response, return a default duration based on question count
+        default_duration = min(60, max(5, len(questions) * 3))  # 3 minutes per question, capped at 60
+        logger.warning(f"No duration found in AI response. Using default: {default_duration} minutes")
+        return default_duration

backend/services/assessment_service.py

@@ -67,11 +67,20 @@ def create_assessment(db: Session, job_id: str, assessment: AssessmentCreate) ->
     # Convert the generated questions to JSON
     questions_json = json.dumps([q.model_dump() for q in generated_questions])
 
+    # Estimate the duration using AI
+    from services.ai_service import estimate_assessment_duration
+    duration = estimate_assessment_duration(
+        title=assessment.title,
+        job_info=job_info,
+        questions=generated_questions,
+        additional_note=assessment.additional_note
+    )
+
     db_assessment = Assessment(
         id=str(uuid.uuid4()),
         job_id=job_id,
         title=assessment.title,
-        duration=getattr(assessment, 'duration', None),  # Include duration if available
+        duration=duration,
         passing_score=assessment.passing_score,
         questions=questions_json,  # Store as JSON string
         active=True
@@ -92,12 +101,76 @@ def update_assessment(db: Session, assessment_id: str, **kwargs) -> Optional[Ass
                 if isinstance(value, list):
                     # Value is already a JSON string if coming from regenerate_assessment
                     setattr(db_assessment, key, json.dumps([q.model_dump() if hasattr(q, 'model_dump') else q for q in value]))
+                    
+                    # If questions are being updated, recalculate the duration using AI
+                    from services.ai_service import estimate_assessment_duration
+                    from models.job import Job
+                    import json
+                    
+                    # Get the job information
+                    job = db.query(Job).filter(Job.id == db_assessment.job_id).first()
+                    job_info = {}
+                    if job:
+                        job_info = {
+                            "title": job.title,
+                            "seniority": job.seniority,
+                            "description": job.description,
+                            "skill_categories": json.loads(job.skill_categories) if job.skill_categories else []
+                        }
+                    
+                    # Parse the questions to pass to the AI
+                    questions = [q for q in value]
+                    
+                    # Estimate new duration based on updated questions
+                    duration = estimate_assessment_duration(
+                        title=db_assessment.title,
+                        job_info=job_info,
+                        questions=questions,
+                        additional_note=None  # Use None or get from somewhere if available
+                    )
+                    setattr(db_assessment, 'duration', duration)
                 elif isinstance(value, str):
                     # Value is already a JSON string
                     setattr(db_assessment, key, value)
+                    
+                    # If questions are being updated as a JSON string, parse them to estimate duration
+                    try:
+                        parsed_questions = json.loads(value)
+                        from schemas.assessment import AssessmentQuestion
+                        from services.ai_service import estimate_assessment_duration
+                        from models.job import Job
+                        
+                        # Get the job information
+                        job = db.query(Job).filter(Job.id == db_assessment.job_id).first()
+                        job_info = {}
+                        if job:
+                            job_info = {
+                                "title": job.title,
+                                "seniority": job.seniority,
+                                "description": job.description,
+                                "skill_categories": json.loads(job.skill_categories) if job.skill_categories else []
+                            }
+                        
+                        # Convert parsed questions to AssessmentQuestion objects
+                        questions = [AssessmentQuestion(**q) for q in parsed_questions]
+                        
+                        # Estimate new duration based on updated questions
+                        duration = estimate_assessment_duration(
+                            title=db_assessment.title,
+                            job_info=job_info,
+                            questions=questions,
+                            additional_note=None  # Use None or get from somewhere if available
+                        )
+                        setattr(db_assessment, 'duration', duration)
+                    except Exception as e:
+                        logger.warning(f"Could not estimate duration from JSON questions: {str(e)}")
+                        # If parsing fails, we'll skip duration recalculation
                 else:
                     # Handle other cases
                     setattr(db_assessment, key, json.dumps(value))
+            elif key == 'duration':
+                # Skip setting duration since it's handled by AI
+                continue
             else:
                 setattr(db_assessment, key, value)
         db.commit()
@@ -149,6 +222,19 @@ def regenerate_assessment(db: Session, assessment_id: str, **kwargs) -> Optional
 
         # Update the kwargs to use the generated questions
         kwargs['questions'] = questions_json
+        
+        # Estimate the duration using AI
+        from services.ai_service import estimate_assessment_duration
+        # Get the original assessment to access its title
+        original_assessment = get_assessment(db, assessment_id)
+        duration = estimate_assessment_duration(
+            title=original_assessment.title,
+            job_info=job_info,
+            questions=generated_questions,
+            additional_note=additional_note
+        )
+        kwargs['duration'] = duration
+
         # Remove questions_types from kwargs as it's not a field in the Assessment model
         del kwargs['questions_types']