QuantumChecker 0.2.7__tar.gz → 0.2.9__tar.gz

quantumchecker-0.2.9/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: QuantumChecker
+Version: 0.2.9
+Summary: A package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS.
+Author: Qobiljon
+Author-email: qobiljonkhayrullayev@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: tenacity>=8.2.3
+Requires-Dist: pdf2image>=1.16.3
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: Pillow>=10.0.0
+Requires-Dist: PyPDF2>=3.0.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Sample usage: 
+```
+import asyncio
+from your_evaluator_module import HomeworkEvaluator
+
+async def main():
+    evaluator = HomeworkEvaluator()
+    question_content = """
+Q1: What is a Python list? Explain with an example.
+
+Q2: Write an SQL query to select all records from a table named 'students'.
+"""
+    answer_path = "sample_submissions/student1_answer.py"
+    api_keys = ["your_api_key_1", "your_api_key_2"]
+    question_type = "python"
+
+    result = await evaluator.evaluate_from_content(
+        question_content=question_content,
+        answer_path=answer_path,
+        api_keys=api_keys,
+        question_type=question_type
+    )
+    print(result)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

quantumchecker-0.2.9/QuantumCheck/main.py

@@ -0,0 +1,222 @@
+import logging
+import os
+import zipfile
+import random
+from datetime import datetime
+from typing import List, Dict, Optional
+from .python_evaluator import PythonEvaluator
+from .sql_evaluator import SQLEvaluator
+from .powerbi_evaluator import PowerBIEvaluator
+from .ssis_evaluator import SSISEvaluator
+import asyncio
+
+_logger_cache = {}
+
+class HomeworkEvaluator:
+    EVALUATOR_REGISTRY = {
+        "python": PythonEvaluator,
+        "sql": SQLEvaluator,
+        "powerbi": PowerBIEvaluator,
+        "ssis": SSISEvaluator
+    }
+
+    EXTENSION_TO_TYPE = {
+        ".py": "python",
+        ".sql": "sql",
+        ".pbit": "powerbi",
+        ".pdf": "powerbi",
+        ".dtsx": "ssis",
+        ".DTSX": "ssis",
+        ".txt": "text",
+        ".md": "text"
+    }
+
+    API_NAME_MAPPING = {
+        "python": "Google Gemini API",
+        "sql": "Google Gemini API",
+        "powerbi": "Google Gemini API",
+        "ssis": "Google Gemini API",
+        "text": "Google Gemini API"
+    }
+
+    def __init__(self, log_level: int = logging.INFO):
+        self.log_level = log_level
+        self._successful_key_cache = {}
+        self._rate_limit_delay = {}  # Track delay per key
+
+    def _get_logger(self, log_type: str) -> logging.Logger:
+        log_name = f"{log_type}_{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}"
+        if log_name not in _logger_cache:
+            logger = logging.getLogger(log_name)
+            logger.setLevel(self.log_level)
+            if not logger.handlers:
+                handler = logging.StreamHandler()
+                handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+                logger.addHandler(handler)
+            _logger_cache[log_name] = logger
+        return _logger_cache[log_name]
+
+    def parse_questions(self, content: str) -> List[str]:
+        logger = self._get_logger("QuantumCheck.main")
+        questions = [q.strip() for q in content.split("\n\n") if q.strip()]
+        logger.info(f"Parsed {len(questions)} questions from content")
+        if not questions:
+            raise ValueError("No valid questions found in content")
+        return questions
+
+    def _detect_zip_content_type(self, zip_path: str, logger: logging.Logger) -> str:
+        try:
+            with zipfile.ZipFile(zip_path, "r") as zip_ref:
+                extensions = {os.path.splitext(name)[1].lower() for name in zip_ref.namelist()}
+                file_types = [self.EXTENSION_TO_TYPE.get(ext, "text") for ext in extensions if ext]
+                logger.info(f"Detected extensions in ZIP {zip_path}: {extensions}, types: {file_types}")
+                if "python" in file_types:
+                    logger.info(f"Selected file type: python from extension: .py in ZIP: {zip_path}")
+                    return "python"
+                elif "sql" in file_types:
+                    logger.info(f"Selected file type: sql from extension: .sql in ZIP: {zip_path}")
+                    return "sql"
+                elif "powerbi" in file_types:
+                    logger.info(f"Selected file type: powerbi from extension: .pbit or .pdf in ZIP: {zip_path}")
+                    return "powerbi"
+                elif "ssis" in file_types:
+                    logger.info(f"Selected file type: ssis from extension: .dtsx in ZIP: {zip_path}")
+                    return "ssis"
+                else:
+                    logger.info(f"Selected file type: text (default) in ZIP: {zip_path}")
+                    return "text"
+        except zipfile.BadZipFile:
+            logger.error(f"Invalid ZIP file: {zip_path}")
+            raise ValueError(f"Invalid ZIP file: {zip_path}")
+
+    async def evaluate_from_content(
+            self,
+            question_content: str,
+            answer_path: str,
+            api_keys: List[str],
+            question_type: str
+    ) -> Dict[str, any]:
+        try:
+            questions = self.parse_questions(question_content)
+        except ValueError as e:
+            logger = self._get_logger("QuantumCheck.main")
+            logger.error("Failed to parse question content: %s", str(e))
+            return {
+                "score": 0,
+                "feedback": f"Error parsing question content: {str(e)}",
+                "issues": [str(e)],
+                "recommendations": [],
+                "used_api_key_index": None,
+                "used_api_name": None
+            }
+
+        answer_path = answer_path.strip()
+        _, ext = os.path.splitext(answer_path)
+        ext = ext.lower()
+
+        # Determine file type, prioritizing question_type for evaluator selection
+        if ext == ".zip":
+            logger = self._get_logger("zip")
+            file_type = self._detect_zip_content_type(answer_path, logger)
+        else:
+            file_type = self.EXTENSION_TO_TYPE.get(ext, "text")
+            logger = self._get_logger(file_type)
+
+        # Use question_type if provided, else fallback to file_type
+        eval_type = question_type if question_type in self.EVALUATOR_REGISTRY else file_type
+        logger.info(f"Processing answer_path: {answer_path} with detected file type: {file_type}, evaluation type: {eval_type}")
+
+        if not os.path.exists(answer_path):
+            logger.error(f"Answer file not found: {answer_path}")
+            return {
+                "score": 0,
+                "feedback": f"Answer file not found: {answer_path}",
+                "issues": [f"Answer file not found: {answer_path}"],
+                "recommendations": [],
+                "used_api_key_index": None,
+                "used_api_name": None
+            }
+
+        evaluator_class = self.EVALUATOR_REGISTRY.get(eval_type, PythonEvaluator)
+        last_error_messages = []
+
+        # Shuffle keys for load balancing
+        key_order = [(i + 1, key) for i, key in enumerate(api_keys)]
+        random.shuffle(key_order)
+
+        # Try cached key with 30% probability to encourage rotation
+        cached_key_idx = self._successful_key_cache.get(eval_type)
+        if cached_key_idx is not None and cached_key_idx < len(api_keys) and random.random() < 0.3:
+            key_order.insert(0, (cached_key_idx + 1, api_keys[cached_key_idx]))
+
+        for idx, key in key_order:
+            # Check rate limit delay
+            if key in self._rate_limit_delay:
+                delay_until = self._rate_limit_delay[key]
+                current_time = datetime.now()
+                delay_until_time = datetime.fromtimestamp(delay_until)
+                if current_time < delay_until_time:
+                    logger.info(f"API key #{idx} is rate-limited until {delay_until_time}, skipping.")
+                    continue
+                else:
+                    del self._rate_limit_delay[key]
+
+            logger.info(f"Trying API key #{idx}")
+            evaluator = evaluator_class(key)
+            api_name = getattr(evaluator, 'get_api_name', lambda: self.API_NAME_MAPPING.get(eval_type, "Unknown API"))()
+            logger.info(f"Using API: {api_name} for evaluation type: {eval_type}")
+
+            try:
+                evaluation = evaluator.evaluate(questions, answer_path, temp_dir=f"temp_extract_{os.getpid()}_{idx}")
+
+                feedback = evaluation.get("feedback", "").lower()
+                issues = " ".join(evaluation.get("issues", [])).lower()
+
+                # Check for invalid API key
+                if any(phrase in feedback or phrase in issues for phrase in ["api key not valid", "api_key_invalid"]):
+                    logger.warning(f"API key #{idx} invalid, trying next key.")
+                    last_error_messages.append(f"API key #{idx} invalid.")
+                    continue
+
+                # Check for rate limit errors
+                if any(phrase in feedback or phrase in issues for phrase in ["429", "too many requests", "rate limit"]):
+                    logger.warning(f"API key #{idx} hit rate limit, applying delay.")
+                    last_error_messages.append(f"API key #{idx} rate limited.")
+                    self._rate_limit_delay[key] = datetime.now().timestamp() + 45  # 45s delay
+                    continue
+
+                # Check for invalid evaluation
+                if evaluation.get("score", 0) == 0 and "evaluation not returned" in feedback:
+                    logger.warning(f"API key #{idx} returned invalid evaluation, trying next key.")
+                    last_error_messages.append(f"API key #{idx} returned invalid evaluation.")
+                    continue
+
+                # Cache successful key
+                self._successful_key_cache[eval_type] = idx - 1
+                logger.info(f"Evaluation succeeded with API key #{idx}: Score = {evaluation.get('score')}")
+
+                return {
+                    "score": evaluation.get("score", 0),
+                    "feedback": evaluation.get("feedback", "No feedback provided"),
+                    "issues": evaluation.get("issues", []),
+                    "recommendations": evaluation.get("recommendations", []),
+                    "used_api_key_index": idx,
+                    "used_api_name": api_name
+                }
+
+            except Exception as e:
+                logger.error(f"Exception using API key #{idx}: {str(e)}")
+                last_error_messages.append(f"Exception with key #{idx}: {str(e)}")
+                if "429" in str(e) or "rate limit" in str(e).lower():
+                    self._rate_limit_delay[key] = datetime.now().timestamp() + 45
+                continue
+
+        logger.error("Evaluation failed with all API keys.")
+        return {
+            "score": 0,
+            "feedback": "Evaluation failed with all API keys.",
+            "issues": last_error_messages if last_error_messages else ["All API keys failed to evaluate the submission."],
+            "recommendations": [],
+            "used_api_key_index": None,
+            "used_api_name": None
+        }

{quantumchecker-0.2.7 → quantumchecker-0.2.9}/QuantumCheck/powerbi_evaluator.py

@@ -15,7 +15,6 @@ import io
 import base64
 
 
-# Placeholder for prompts.py content
 def prompt_text_powerbi(combined_content: str) -> str:
     return f"""
     Evaluate the following Power BI DAX question-answer pairs for correctness, clarity, and appropriateness.
@@ -46,19 +45,20 @@ class GeminiFlashModel:
         self.model_name = model_name
         self.endpoint = f"https://generativelanguage.googleapis.com/v1beta/models/{model_name}:generateContent"
 
-    @retry(stop=stop_after_attempt(3), wait=wait_exponential(min=4, max=10),
-           retry=retry_if_exception_type((requests.exceptions.RequestException,)))
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(min=4, max=10),
+        retry=retry_if_exception_type((requests.exceptions.RequestException,))
+    )
     def evaluate(self, question_answer_pairs: List[Dict[str, str]]) -> Dict[str, any]:
         logger.info("Starting evaluation of %d Power BI question-answer pairs", len(question_answer_pairs))
         combined_content = "\n\n".join(
             f"Question {i}:\n{qa['question']}\n\nAnswer {i}:\n{qa['answer']}\n"
             for i, qa in enumerate(question_answer_pairs, 1)
         )
-
         headers = {"Content-Type": "application/json"}
         data = {"contents": [{"parts": [{"text": prompt_text_powerbi(combined_content)}]}]}
         response = requests.post(f"{self.endpoint}?key={self.api_key}", headers=headers, json=data)
-
         if response.status_code != 200:
             logger.error("API request failed: Status %d, Response: %s", response.status_code, response.text)
             raise Exception(f"API call failed: {response.status_code} - {response.text}")
@@ -69,8 +69,11 @@ class GeminiFlashModel:
         generated_text = response_data["candidates"][0]["content"]["parts"][0]["text"]
         return self._parse_response(generated_text)
 
-    @retry(stop=stop_after_attempt(3), wait=wait_exponential(min=4, max=10),
-           retry=retry_if_exception_type((requests.exceptions.RequestException,)))
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(min=4, max=10),
+        retry=retry_if_exception_type((requests.exceptions.RequestException,))
+    )
     def evaluate_visuals(self, question: str, image_folder: str) -> Dict[str, any]:
         folder_path = Path(image_folder)
         images = list(folder_path.glob("*.png"))[:3]
@@ -80,12 +83,12 @@ class GeminiFlashModel:
             "Evaluate the Power BI report visuals based on the provided task. The visuals are professional dashboards designed for enterprise use.\n\n"
             f"Task: {question}\n\n"
             f"Screenshots: {[str(img.name) for img in images]}\n\n"
-            "Evaluate based on the following criteria, assigning a score out of 100:z\n"
+            "Evaluate based on the following criteria, assigning a score out of 100:\n"
             "- Clarity (30%): Are visuals clear, with readable labels, titles, and legends?\n"
             "- Appropriateness (30%): Are chart types (e.g., bar, line, pie) suitable for the data and task?\n"
             "- Color Usage (20%): Are colors consistent, accessible, and visually appealing? Consider contrast and colorblind accessibility.\n"
             "- Interactivity (20%): Do visible slicers, filters, or tooltips enhance usability and data exploration?\n\n"
-            "Provide a score (0-100) that reflects the overall quality, considering the enterprise context. Avoid overly harsh penalties for minor issues.\n"
+            "Provide a score for overall quality, considering the enterprise context. Avoid overly harsh penalties for minor issues.\n"
             "Provide concise, supportive feedback for beginners, highlighting strengths and areas for improvement.\n\n"
             "Structure the response as:\n"
             "Score: [SCORE]/100\n"
@@ -231,9 +234,7 @@ class PowerBIProcessor:
                     measures.append({
                         "Table": table["name"],
                         "Name": measure["name"],
-                        "Expression": " ".join(measure.get("expression", "")) if isinstance(measure.get("expression"),
-                                                                                            list) else measure.get(
-                            "expression", ""),
+                        "Expression": " ".join(measure.get("expression", "")) if isinstance(measure.get("expression"), list) else measure.get("expression", ""),
                         "FormatString": measure.get("formatString", "")
                     })
         return measures
@@ -242,19 +243,31 @@ class PowerBIProcessor:
     def _get_tables_and_columns(tables: List[Dict]) -> List[Dict]:
         table_info = []
         for table in tables:
-            columns = [{"Column Name": col["name"], "Data Type": col.get("dataType", "Unknown"),
-                        "Source Column": col.get("sourceColumn", "N/A"), "Calculated": col.get("type") == "calculated"}
-                       for col in table.get("columns", [])]
-            expressions = [part["source"]["expression"] for part in table.get("partitions", []) if
-                           part["source"].get("expression")]
+            columns = [
+                {
+                    "Column Name": col["name"],
+                    "Data Type": col.get("dataType", "Unknown"),
+                    "Source Column": col.get("sourceColumn", "N/A"),
+                    "Calculated": col.get("type") == "calculated"
+                }
+                for col in table.get("columns", [])
+            ]
+            expressions = [part["source"]["expression"] for part in table.get("partitions", []) if part["source"].get("expression")]
             table_info.append({"Table Name": table["name"], "Columns": columns, "Expressions": expressions})
         return table_info
 
     @staticmethod
     def _get_relationships(relationships: List[Dict]) -> List[Dict]:
-        return [{"From Table": rel["fromTable"], "From Column": rel["fromColumn"], "To Table": rel["toTable"],
-                 "To Column": rel["toColumn"], "Join Behavior": rel.get("joinOnDateBehavior", "N/A")} for rel in
-                relationships]
+        return [
+            {
+                "From Table": rel["fromTable"],
+                "From Column": rel["fromColumn"],
+                "To Table": rel["toTable"],
+                "To Column": rel["toColumn"],
+                "Join Behavior": rel.get("joinOnDateBehavior", "N/A")
+            }
+            for rel in relationships
+        ]
 
     @staticmethod
     def _cleanup(*paths: str):
@@ -272,15 +285,13 @@ class PowerBIEvaluator:
         self.model = GeminiFlashModel(api_key)
         self.processor = PowerBIProcessor()
 
-    def evaluate(self, questions: List[str], answer_path: str) -> Dict[str, any]:
+    def evaluate(self, questions: List[str], answer_path: str, temp_dir: str = "temp_extract") -> Dict[str, any]:
         try:
             _, ext = os.path.splitext(answer_path)
             ext = ext.lower()
-            extract_path = os.path.join(os.path.dirname(answer_path), "temp_extract")
+            extract_path = temp_dir
             pbit_path = None
             pdf_path = None
-
-            # Handle input file type
             if ext == ".zip":
                 pbit_path, pdf_path = self.processor.extract_zip(answer_path, extract_path)
             elif ext == ".pbit":
@@ -296,61 +307,47 @@ class PowerBIEvaluator:
                     "dax_score": 0,
                     "visual_score": 0
                 }
-
             try:
-                # Extract and process the data model from .pbit
                 data_model = self.processor.extract_datamodel(pbit_path)
                 model_data = self.processor.extract_model_data(data_model)
                 answers = [json.dumps(model_data)] * len(questions)
                 dax_result = self.model.evaluate([{"question": q, "answer": a} for q, a in zip(questions, answers)])
-
-                # Initialize result with DAX evaluation
                 result = {
                     "score": 0,
                     "feedback": f"DAX Feedback:\n{dax_result['feedback']}",
                     "issues": dax_result["issues"],
                     "recommendations": dax_result["recommendations"],
-                    "dax_score": dax_result["score"],  # Store DAX score
-                    "visual_score": 0  # Default visual score
+                    "dax_score": dax_result["score"],
+                    "visual_score": 0
                 }
-
-                # Process PDF and evaluate visuals if present
                 if pdf_path:
                     try:
-                        self.processor.process_pdf(pdf_path)
-                        visual_result = self.model.evaluate_visuals(questions[0], "outputimages")
-                        # Apply 70% DAX, 30% visuals scoring
+                        image_paths = self.processor.process_pdf(pdf_path, output_dir=os.path.join(temp_dir, "outputimages"))
+                        visual_result = self.model.evaluate_visuals(questions[0], os.path.join(temp_dir, "outputimages"))
                         result["score"] = int(0.7 * dax_result["score"] + 0.3 * visual_result["score"])
-                        result["visual_score"] = visual_result["score"]  # Store visual score
+                        result["visual_score"] = visual_result["score"]
                         result["feedback"] += f"\n\nVisual Feedback:\n{visual_result['feedback']}"
                         result["issues"].extend([f"Visual: {i}" for i in visual_result.get("issues", [])])
                         result["recommendations"].extend(visual_result.get("recommendations", []))
                     except ProcessingError as e:
                         logger.warning("Failed to process PDF, proceeding with DAX evaluation only: %s", str(e))
-                        # Use DAX score only, weighted at 100% if no visuals
                         result["score"] = dax_result["score"]
                         result["issues"].append(f"Visual evaluation skipped: {str(e)}")
-                        result["recommendations"].append(
-                            "Ensure a valid PDF is provided for visual evaluation if intended")
+                        result["recommendations"].append("Ensure a valid PDF is provided for visual evaluation if intended")
                 else:
-                    # No PDF provided, use DAX score only
                     result["score"] = dax_result["score"]
                     result["feedback"] += "\n\nVisual Feedback:\nNo visuals provided for evaluation."
                     result["issues"].append("No PDF provided for visual evaluation")
                     result["recommendations"].append("Include a PDF with report visuals for complete evaluation")
-
-                # Print scores with text labels to terminal
                 logger.info("[DAX] Score: %d/100", result["dax_score"])
                 logger.info("[Visual] Score: %d/100", result["visual_score"])
                 logger.info("[Final] Score (70%% DAX, 30%% Visuals): %d/100", result["score"])
-
                 return result
             finally:
-                # Cleanup temporary files and directories
-                self.processor._cleanup(extract_path, "outputimages")
+                self.processor._cleanup(extract_path, os.path.join(temp_dir, "outputimages"))
         except Exception as e:
             logger.exception("Failed to evaluate Power BI file %s: %s", answer_path, str(e))
-            self.processor._cleanup(extract_path, "outputimages")
+            self.processor._cleanup(extract_path, os.path.join(temp_dir, "outputimages"))
             return {
                 "score": 0,
                 "feedback": f"Error processing file: {str(e)}",
@@ -362,4 +359,4 @@ class PowerBIEvaluator:
 
 
 class ProcessingError(Exception):
-    pass
+    pass

{quantumchecker-0.2.7 → quantumchecker-0.2.9}/QuantumCheck/prompts.py

@@ -8,10 +8,10 @@ def prompt_text_python(combined_content):
         "- Highlight both strengths and areas for improvement\n"
         "- Identify major mistakes or misunderstandings (e.g., syntax errors, incorrect logic, missing components and conceptual part)\n"
         "- Be concise but insightful\n\n"
-        "- If the student's answer is incomplete or too simplistic to fully address the question, "
+        "- If the student's answer is incomplete or too simplistic to fully address the question, you should decrease the mark for the missing answers"
         "explain that the response lacks depth or coverage, but do not provide the missing or correct answer. "
         "Encourage the student to research further or review the relevant concepts.\n"
-        "- If the student's submission is off-topic or unrelated to the question, "
+        "- If the student's submission is off-topic or unrelated to the question, give exatly 20 mark and "
         "clearly state that the response does not address the question's requirements and "
         "explain why it is irrelevant. Encourage the student to review the question carefully and "
         "focus on the relevant Python concepts without providing the correct solution."
@@ -32,8 +32,6 @@ def prompt_text_python(combined_content):
         "- Be honest but supportive\n"
         "- Include specific examples from the provided answers if helpful\n"
         "- Keep language beginner-friendly\n"
-        "- Do not give too low marks. You may add from 20 up to 25 additional marks for effort or "
-        "partial relevance, ensuring the score does not exceed 100."
     )
 
 
@@ -57,7 +55,7 @@ def prompt_text_sql(combined_content: str):
             "clearly state that it lacks sufficient detail or misses key components, but do not provide "
             "the missing parts or solutions. Instead, suggest they revisit the relevant "
             "concepts (e.g., joins, subqueries, indexing, if lacks) and encourage deeper exploration.\n"
-            "- If the student's submission is off-topic or unrelated to the question, "
+            "- If the student's submission is off-topic or unrelated to the question, give exactly 20 mark and "
             "clearly state that the response does not address the question's requirements and "
             "explain why it is irrelevant. Encourage the student to review the "
             "question carefully and focus on the relevant SQL Server concepts without providing the correct solution."
@@ -76,6 +74,7 @@ def prompt_text_sql(combined_content: str):
             f"{combined_content}\n"
             "=== EVALUATION COMPLETE ===\n\n"
             "Notes:\n"
+            "If question about other technology for example python then it is clearly off topic and should get 20 mark"
             "- Be honest but supportive\n"
             "- Include specific examples from the provided answers if helpful\n"
             "- Keep language beginner-friendly\n"
@@ -83,62 +82,43 @@ def prompt_text_sql(combined_content: str):
             "effort or partial relevance, ensuring the score does not exceed 100."
         )
 
-def prompt_text_ssis(combined_content):
+def prompt_text_ssis(combined_content: str) -> str:
     return (
-            "You are a data engineer reviewing an SSIS package (.dtsx) summary. "
-            "Evaluate how well the package addresses the question, focusing on the correctness of tasks, "
-            "data flow, control flow, and configurations.\n\n"
-            "Your evaluation should:\n"
-            "- Assess how well the package addresses the question overall\n"
-            "- Focus on clarity, accuracy, and a basic understanding of key SSIS components "
-            "(e.g., Control Flow, Data Flow, Connection Managers)\n"
-            "- Be supportive and constructive — students are new to SSIS, so encourage learning and reward effort\n"
-            "- Highlight what was done well and gently suggest what could be improved\n"
-            "- Point out only major issues when necessary (e.g., missing essential components, "
-            "incorrect configurations, or clear misunderstandings)\n"
-            "- Keep feedback clear, concise, and insightful\n"
-            "- Also assess whether the student’s submission demonstrates a proper understanding of "
-            "SSIS concepts being tested (e.g., ETL processes, control flow sequencing, error handling), not just technical correctness\n"
-            "- Check for proper use of control flow tasks, data flow transformations, precedence constraints, "
-            "error handling (e.g., OnError events), and connection manager configurations\n"
-            "- If the student's submission is incomplete or too simplistic to fully address the question, "
-            "clearly state that it lacks sufficient detail or misses key components, "
-            "but do not provide the missing parts or solutions. Instead, suggest they revisit the relevant "
-            "SSIS concepts (e.g., control flow, data flow, error handling) and encourage deeper exploration\n"
-            "- If the student's submission is off-topic or unrelated to the question, "
-            "clearly state that the response does not address the question's requirements and "
-            "explain why it is irrelevant. Encourage the student to review the question carefully and "
-            "focus on the relevant SSIS concepts without providing the correct solution\n"
-            "- Understand that simple packages may only use one Data Flow Task, and that’s perfectly fine\n"
-            "- If scheduling (e.g., daily at 7 AM) is not included, just note it briefly — "
-            "it may be handled by SQL Server Agent and should not impact the score significantly (no more than 5–10 points)\n\n"
-            "When provided, check that:\n"
-            "- Data flow connections are properly linked\n"
-            "- Data types match the destination schema\n\n"
-            "Important Scoring Note:\n"
-            "Always give credit for effort, even if there are technical gaps. It’s better to nudge students forward "
-            "than to discourage them. Start from a generous baseline and avoid very low scores unless the submission "
-            "shows no attempt. Remember the student is not a pro programmer, so avoid low scores just because best "
-            "practices weren’t followed exactly. Score mainly based on what was asked. "
-            "Provide feedback in this format:\n\n"
-            "=== COMPREHENSIVE EVALUATION ===\n\n"
-            "OVERALL SCORE: <score>/100\n\n"
-            "FEEDBACK SUMMARY:\n"
-            "- What was done well\n"
-            "- What needs improvement\n"
-            "- Any major issues (e.g., logic errors, misunderstandings, incomplete solutions)\n\n"
-            "KEY ADVICE:\n"
-            "- Top 2-3 suggestions to improve SSIS skills\n"
-            "- Concepts to revisit\n"
-            "- Encouragement to keep learning and improving\n\n"
-            f"{combined_content}\n"
-            "=== EVALUATION COMPLETE ===\n\n"
-            "Notes:\n"
-            "- Be honest but supportive\n"
-            "- Include specific examples from the provided summary if helpful\n"
-            "- Keep language beginner-friendly\n"
-            "- Do not give too low marks. From 5 up to 10 additional marks for effort or partial relevance, ensuring the score does not exceed 100."
-        )
+
+        "You are an SSIS data engineer evaluating a beginner-level SSIS package submission (1–2 months experience).\n\n"
+        "Evaluation Criteria:\n"
+        "- Assess correct and relevant use of SSIS components: Connection Managers, Control Flow tasks (e.g., Execute SQL Task), Data Flow tasks (e.g., Flat File Source to OLE DB Destination).\n"
+        "- Check if the submission attempts to solve the task using SSIS packages (.dtsx) and related concepts.\n"
+        "- Confirm proper linking of components and appropriate use of data types.\n"
+        "- Consider clarity, effort, and completeness.\n"
+        "- If scheduling (e.g., SQL Server Agent Job) is missing, note it but deduct no more than 5 points.\n\n"
+        "**STRICT RULE ON OFF-TOPIC SUBMISSIONS:**\n"
+        "- If the submission is off-topic (e.g., Python scripts, SQL queries, Power BI reports, or anything NOT an SSIS package or SSIS-related), assign exactly 20/100 points.\n"
+        "- Do NOT give any additional points or feedback related to SSIS components.\n"
+        "- Clearly state in feedback that the submission does not address the SSIS package requirement and advise focusing on SSIS for this task.\n\n"
+        "Scoring Guidelines:\n"
+        "- Begin with a baseline of 60/100 for any reasonable SSIS attempt.\n"
+        "- Add 5–10 points for extra effort or partial correctness.\n"
+        "- Never exceed 100 points.\n"
+        "- Always reward genuine effort unless off-topic.\n\n"
+        "Feedback Format:\n"
+        "=== COMPREHENSIVE EVALUATION ===\n"
+        "OVERALL SCORE: <score>/100\n\n"
+        "FEEDBACK SUMMARY:\n"
+        "- What was done well\n"
+        "- What needs improvement\n"
+        "- Major issues (including off-topic comments if applicable)\n\n"
+        "KEY ADVICE:\n"
+        "- 1–2 improvement tips\n"
+        "- Core SSIS concepts to review\n"
+        "- Encouragement to keep practicing\n\n"
+        f"{combined_content}\n"
+        "=== EVALUATION COMPLETE ===\n\n"
+        "Notes:\n"
+        "- Be kind, clear, and beginner-friendly.\n"
+        "- If off-topic, strictly enforce 20/100 score with no exceptions.\n"
+        "- Remind student clearly to read the question carefully and focus on SSIS.\n"
+    )
 
 def prompt_text_powerbi(combined_content: str):
     return (
@@ -156,7 +136,7 @@ def prompt_text_powerbi(combined_content: str):
     "- Highlight strengths and areas to improve\n"
     "- Mention if the submission is incomplete or off-topic, but don't provide missing solutions\n"
     "- Do not penalize for efficiency, missing advanced features, or redundant tables\n"
-    "- Base score on relevance, correctness, and effort. Incomplete/off-topic work should be scored low, with a small boost for effort if applicable\n\n"
+    "- Base score on relevance, correctness, and effort. Incomplete/off-topic work should be scored low and and should not be given any feedbacks related, with a small boost for effort if applicable\n\n"
     f"{combined_content}\n"
     "=== EVALUATION COMPLETE ==="
 )