QuantumChecker 0.2.3__tar.gz → 0.2.5__tar.gz

{quantumchecker-0.2.3 → quantumchecker-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuantumChecker
-Version: 0.2.3
+Version: 0.2.5
 Summary: A package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS.
 Author: Qobiljon
 Author-email: qobiljonkhayrullayev@gmail.com

{quantumchecker-0.2.3 → quantumchecker-0.2.5}/QuantumCheck/powerbi_evaluator.py

@@ -24,15 +24,17 @@ logging.basicConfig(
     handlers=[logging.FileHandler("../powerbi_evaluator.log"), logging.StreamHandler()]
 )
 
-# GeminiFlashModel class remains unchanged
 class GeminiFlashModel:
     def __init__(self, api_key: str, model_name: str = "gemini-1.5-flash"):
+        logger.info("Initializing GeminiFlashModel with model: %s", model_name)
         api_key = os.getenv("GEMINI_API_KEY") or api_key
         if not api_key:
+            logger.error("API key not found in environment variables or provided argument")
             raise ValueError("API key not found in .env file or environment variables.")
         self.api_key = api_key
         self.model_name = model_name
         self.endpoint = f"https://generativelanguage.googleapis.com/v1beta/models/{model_name}:generateContent"
+        logger.info("GeminiFlashModel initialized successfully with endpoint: %s", self.endpoint)
 
     @retry(
         stop=stop_after_attempt(3),
@@ -40,14 +42,16 @@ class GeminiFlashModel:
         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))
+        logger.info("Starting evaluation of %d 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)
         )
+        logger.debug("Prepared combined content for evaluation: %s", combined_content[:100] + "..." if len(combined_content) > 100 else combined_content)
 
         headers = {"Content-Type": "application/json"}
         data = {"contents": [{"parts": [{"text": prompt_text_powerbi(combined_content)}]}]}
+        logger.info("Sending API request to %s", self.endpoint)
         response = requests.post(f"{self.endpoint}?key={self.api_key}", headers=headers, json=data)
 
         if response.status_code != 200:
@@ -58,6 +62,7 @@ class GeminiFlashModel:
             logger.error("API response missing candidates: %s", response_data)
             raise ValueError("No candidates in API response")
         generated_text = response_data["candidates"][0]["content"]["parts"][0]["text"]
+        logger.info("Received API response, parsing generated text")
         return self._parse_response(generated_text)
 
     @retry(
@@ -66,10 +71,14 @@ class GeminiFlashModel:
         retry=retry_if_exception_type((requests.exceptions.RequestException,))
     )
     def evaluate_visuals(self, question: str, image_folder: str) -> Dict[str, any]:
+        logger.info("Starting visual evaluation for question: %s", question)
         folder_path = Path(image_folder)
         images = list(folder_path.glob("*.png"))[:3]
         if not images:
+            logger.error("No PNG images found in folder: %s", image_folder)
             raise ProcessingError(f"No PNG images found in {image_folder}")
+        logger.info("Found %d PNG images for evaluation: %s", len(images), [img.name for img in images])
+
         prompt = (
             "Evaluate the Power BI report visuals based on the given task.\n\n"
             f"Task: {question}\n\n"
@@ -87,6 +96,7 @@ class GeminiFlashModel:
         )
         parts = [{"text": prompt}]
         for img in images:
+            logger.debug("Processing image: %s", img.name)
             with Image.open(img) as pil_img:
                 pil_img.thumbnail((1024, 1024))
                 img_buffer = io.BytesIO()
@@ -99,23 +109,28 @@ class GeminiFlashModel:
                 })
         headers = {"Content-Type": "application/json"}
         data = {"contents": [{"parts": parts}]}
+        logger.info("Sending visual evaluation API request to %s", self.endpoint)
         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)
+            logger.error("Visual API request failed: Status %d, Response: %s", response.status_code, response.text)
             raise Exception(f"API call failed: {response.status_code} - {response.text}")
         response_data = response.json()
         if not response_data.get("candidates"):
-            logger.error("API response missing candidates: %s", response_data)
+            logger.error("Visual API response missing candidates: %s", response_data)
             raise ValueError("No candidates in API response")
         output_text = response_data["candidates"][0]["content"]["parts"][0]["text"]
+        logger.info("Received visual API response, parsing output")
         score_match = re.search(r"Score:\s*(\d+)(?:/100)?", output_text)
         feedback_match = re.search(r"Feedback:\s*(.*)", output_text, re.DOTALL)
-        return {
+        result = {
             "score": int(score_match.group(1)) if score_match else 0,
             "feedback": feedback_match.group(1).strip() if feedback_match else "No visual feedback generated"
         }
+        logger.info("Visual evaluation completed: Score=%d, Feedback=%s", result["score"], result["feedback"][:50] + "..." if len(result["feedback"]) > 50 else result["feedback"])
+        return result
 
     def _parse_response(self, text: str) -> Dict[str, any]:
+        logger.info("Parsing API response text")
         result = {"score": 0, "feedback": "Evaluation not returned by API.", "issues": [], "recommendations": []}
         try:
             lines = text.split("\n")
@@ -127,96 +142,136 @@ class GeminiFlashModel:
                     try:
                         result["score"] = int(line.split(":")[1].split("/")[0].strip())
                         score_found = True
+                        logger.info("Parsed score: %d", result["score"])
                     except ValueError:
                         result["issues"].append("Failed to parse score from API response")
+                        logger.error("Failed to parse score from response: %s", line)
                         continue
                 elif score_found:
                     feedback_lines.append(line)
             if feedback_lines:
                 result["feedback"] = "\n".join(feedback_lines).strip()
+                logger.debug("Parsed feedback: %s", result["feedback"][:50] + "..." if len(result["feedback"]) > 50 else result["feedback"])
             return result
         except Exception as e:
             result["issues"].append(str(e))
+            logger.error("Error parsing response: %s", str(e))
             return result
 
 class PowerBIProcessor:
     def extract_datamodel(self, pbit_file_path: str) -> Dict:
+        logger.info("Extracting data model from PBIT file: %s", pbit_file_path)
         if not os.path.exists(pbit_file_path):
+            logger.error("PBIT file does not exist: %s", pbit_file_path)
             raise ProcessingError(f"PBIT file not found: {pbit_file_path}")
         folder_path = os.path.dirname(pbit_file_path)
         file_name = os.path.splitext(os.path.basename(pbit_file_path))[0]
         zip_file = os.path.join(folder_path, f"{file_name}.zip")
         export_path = os.path.join(folder_path, "export")
+        logger.debug("Cleaning up temporary files: %s, %s", zip_file, export_path)
         self._cleanup(zip_file, export_path)
         try:
+            logger.info("Renaming PBIT to ZIP: %s -> %s", pbit_file_path, zip_file)
             os.rename(pbit_file_path, zip_file)
             if not zipfile.is_zipfile(zip_file):
+                logger.error("File is not a valid ZIP: %s", zip_file)
                 raise ProcessingError(f"File is not a valid ZIP: {zip_file}")
+            logger.info("Extracting ZIP contents to: %s", export_path)
             with zipfile.ZipFile(zip_file, "r") as zip_ref:
                 zip_ref.extractall(export_path)
             schema_path = os.path.join(export_path, "DataModelSchema")
             txt_path = os.path.join(export_path, "DataModelSchema.txt")
+            logger.debug("Renaming schema file: %s -> %s", schema_path, txt_path)
             os.rename(schema_path, txt_path)
+            logger.info("Reading DataModelSchema file: %s", txt_path)
             with open(txt_path, "r", encoding="utf-16-le") as file:
-                return json.load(file)
+                data = json.load(file)
+                logger.info("Successfully extracted data model from PBIT file")
+                return data
         except UnicodeDecodeError as e:
             logger.error("Failed to decode DataModelSchema: %s", str(e))
             raise ProcessingError(f"Invalid encoding in DataModelSchema: {e}")
         except Exception as e:
+            logger.error("Failed to extract DataModelSchema: %s", str(e))
             raise ProcessingError(f"Failed to extract DataModelSchema: {e}")
         finally:
+            logger.debug("Cleaning up temporary files after extraction")
             self._cleanup(zip_file, export_path)
 
     def extract_model_data(self, data: Dict) -> Dict:
+        logger.info("Extracting model data from data model")
         try:
             tables = data.get("model", {}).get("tables", [])
             relationships = data.get("model", {}).get("relationships", [])
-            return {
+            result = {
                 "Calculated Measures": self._get_measures(tables),
                 "Tables": self._get_tables_and_columns(tables),
                 "Relationships": self._get_relationships(relationships)
             }
+            logger.info("Extracted model data: %d measures, %d tables, %d relationships",
+                        len(result["Calculated Measures"]), len(result["Tables"]), len(result["Relationships"]))
+            return result
         except Exception as e:
+            logger.error("Failed to extract model data: %s", str(e))
             raise ProcessingError(f"Failed to extract model data: {e}")
 
     def process_pdf(self, pdf_path: str, output_dir: str = "outputimages", num_pages: int = 3) -> List[str]:
+        logger.info("Processing PDF file: %s", pdf_path)
         try:
             if not os.path.exists(pdf_path):
+                logger.error("PDF file does not exist: %s", pdf_path)
                 raise ProcessingError(f"PDF file not found: {pdf_path}")
+            logger.debug("Creating output directory: %s", output_dir)
             os.makedirs(output_dir, exist_ok=True)
+            logger.info("Converting PDF pages to images (max %d pages)", num_pages)
             pages = convert_from_path(pdf_path, first_page=1, last_page=num_pages)
             image_paths = []
             for i, page in enumerate(pages):
                 image_path = os.path.join(output_dir, f"page_{i + 1}.png")
+                logger.debug("Saving page %d as PNG: %s", i + 1, image_path)
                 page.save(image_path, "PNG")
                 image_paths.append(image_path)
+            logger.info("Successfully processed %d pages from PDF", len(image_paths))
+            logger.debug("Removing original PDF file: %s", pdf_path)
             os.remove(pdf_path)
             return image_paths
         except Exception as e:
+            logger.error("Failed to process PDF: %s", str(e))
             raise ProcessingError(f"Failed to process PDF: {e}")
 
     def extract_zip(self, zip_path: str, extract_path: str) -> tuple[str, str | None]:
+        logger.info("Extracting ZIP file: %s", zip_path)
         try:
             if not os.path.exists(zip_path):
+                logger.error("ZIP file does not exist: %s", zip_path)
                 raise ProcessingError(f"ZIP file not found: {zip_path}")
             if not zipfile.is_zipfile(zip_path):
+                logger.error("File is not a valid ZIP: %s", zip_path)
                 raise ProcessingError(f"File is not a valid ZIP: {zip_path}")
+            logger.debug("Creating extraction directory: %s", extract_path)
             os.makedirs(extract_path, exist_ok=True)
             with zipfile.ZipFile(zip_path, "r") as zip_ref:
+                logger.info("Extracting ZIP contents to: %s", extract_path)
                 zip_ref.extractall(extract_path)
             pbit_files = list(Path(extract_path).glob("*.pbit"))
             pdf_files = list(Path(extract_path).glob("*.pdf"))
+            logger.info("Found %d PBIT files and %d PDF files in ZIP", len(pbit_files), len(pdf_files))
             if not pbit_files:
+                logger.error("No PBIT files found in ZIP")
                 raise ProcessingError("ZIP file must contain at least one .pbit file")
             if len(pbit_files) > 1:
+                logger.error("Multiple PBIT files found in ZIP: %s", [str(p) for p in pbit_files])
                 raise ProcessingError("ZIP file contains multiple .pbit files")
             pdf_path = str(pdf_files[0]) if pdf_files else None
+            logger.info("Extracted PBIT file: %s, PDF file: %s", str(pbit_files[0]), pdf_path)
             return str(pbit_files[0]), pdf_path
         except Exception as e:
+            logger.error("Failed to extract ZIP file: %s", str(e))
             raise ProcessingError(f"Failed to extract ZIP file: {e}")
 
     @staticmethod
     def _get_measures(tables: List[Dict]) -> List[Dict]:
+        logger.debug("Extracting measures from tables")
         measures = []
         for table in tables:
             if "measures" in table:
@@ -227,37 +282,50 @@ class PowerBIProcessor:
                         "Expression": " ".join(measure.get("expression", "")) if isinstance(measure.get("expression"), list) else measure.get("expression", ""),
                         "FormatString": measure.get("formatString", "")
                     })
+        logger.debug("Extracted %d measures", len(measures))
         return measures
 
     @staticmethod
     def _get_tables_and_columns(tables: List[Dict]) -> List[Dict]:
+        logger.debug("Extracting tables and columns")
         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")]
             table_info.append({"Table Name": table["name"], "Columns": columns, "Expressions": expressions})
+        logger.debug("Extracted %d tables", len(table_info))
         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]
+        logger.debug("Extracting relationships")
+        result = [{"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]
+        logger.debug("Extracted %d relationships", len(result))
+        return result
 
     @staticmethod
     def _cleanup(*paths: str):
+        logger.debug("Cleaning up paths: %s", paths)
         for path in paths:
             if os.path.exists(path):
                 if os.path.isfile(path):
+                    logger.debug("Removing file: %s", path)
                     os.remove(path)
                 else:
+                    logger.debug("Removing directory: %s", path)
                     shutil.rmtree(path, ignore_errors=True)
+        logger.debug("Cleanup completed")
 
 class PowerBIEvaluator:
     def __init__(self, api_key: str):
+        logger.info("Initializing PowerBIEvaluator")
         self.api_key = api_key
         self.model = GeminiFlashModel(api_key)
         self.processor = PowerBIProcessor()
+        logger.info("PowerBIEvaluator initialized successfully")
 
     def evaluate(self, questions: List[str], answer_path: str) -> Dict[str, any]:
+        logger.info("Starting evaluation for file: %s with %d questions", answer_path, len(questions))
         try:
             _, ext = os.path.splitext(answer_path)
             ext = ext.lower()
@@ -266,13 +334,16 @@ class PowerBIEvaluator:
             pdf_path = None
 
             # Handle input file type
+            logger.debug("Checking file extension: %s", ext)
             if ext == ".zip":
+                logger.info("Processing ZIP file")
                 pbit_path, pdf_path = self.processor.extract_zip(answer_path, extract_path)
             elif ext == ".pbit":
+                logger.info("Processing PBIT file directly")
                 pbit_path = answer_path
                 pdf_path = None
             else:
-                logger.error("Invalid file type for Power BI: %s", answer_path)
+                logger.error("Invalid file type: %s", ext)
                 return {
                     "score": 0,
                     "feedback": f"Invalid file type: {ext}. Expected .pbit or .zip",
@@ -282,9 +353,12 @@ class PowerBIEvaluator:
 
             try:
                 # Extract and process the data model from .pbit
+                logger.info("Extracting data model from PBIT")
                 data_model = self.processor.extract_datamodel(pbit_path)
+                logger.info("Extracting model data")
                 model_data = self.processor.extract_model_data(data_model)
                 answers = [json.dumps(model_data)] * len(questions)
+                logger.info("Evaluating DAX with %d question-answer pairs", len(questions))
                 dax_result = self.model.evaluate([{"question": q, "answer": a} for q, a in zip(questions, answers)])
 
                 # Initialize result with DAX evaluation
@@ -294,24 +368,31 @@ class PowerBIEvaluator:
                     "issues": dax_result["issues"],
                     "recommendations": dax_result["recommendations"]
                 }
+                logger.info("DAX evaluation completed: Score=%d", dax_result["score"])
 
                 # Process PDF and evaluate visuals if present
                 if pdf_path:
+                    logger.info("Processing PDF for visual evaluation: %s", pdf_path)
                     try:
-                        self.processor.process_pdf(pdf_path)
+                        image_paths = self.processor.process_pdf(pdf_path)
+                        logger.info("Evaluating visuals with question: %s", questions[0])
                         visual_result = self.model.evaluate_visuals(questions[0], "outputimages")
                         result["score"] = (dax_result["score"] + visual_result["score"]) // 2
                         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", []))
+                        logger.info("Visual evaluation completed: Score=%d", visual_result["score"])
                     except ProcessingError as e:
                         logger.warning("Failed to process PDF, proceeding with DAX evaluation only: %s", str(e))
                         result["issues"].append(f"Visual evaluation skipped: {str(e)}")
                         result["recommendations"].append("Ensure a valid PDF is provided for visual evaluation if intended")
+                else:
+                    logger.info("No PDF provided, skipping visual evaluation")
 
+                logger.info("Evaluation completed successfully")
                 return result
             finally:
-                # Cleanup temporary files and directories
+                logger.debug("Cleaning up temporary files and directories")
                 self.processor._cleanup(extract_path, "outputimages")
         except Exception as e:
             logger.exception("Failed to evaluate Power BI file %s: %s", answer_path, str(e))

quantumchecker-0.2.5/QuantumCheck/prompts.py

@@ -0,0 +1,230 @@
+def prompt_text_python(combined_content):
+    return (
+        "You are an expert Python instructor evaluating beginner Python code. "
+        "Focus on syntax, logic, code readability, and adherence to Python best practices (e.g., PEP 8).\n\n"
+        "Your evaluation should:\n"
+        "- Focus on clarity, correctness, and understanding of the Python content\n"
+        "- Be constructive and encouraging (students are beginners)\n"
+        "- 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, "
+        "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, "
+        "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."
+        "Provide feedback in this format:\n\n"
+        "=== COMPREHENSIVE EVALUATION ===\n\n"
+        "OVERALL SCORE: /100\n\n"
+        "FEEDBACK SUMMARY:\n"
+        "- What was done well\n"
+        "- What needs improvement\n"
+        "- Any major issues (e.g., logic errors, misunderstanding, incomplete solutions)\n\n"
+        "KEY ADVICE:\n"
+        "- Top 2 or 3 suggestions to improve Python skills\n"
+        "- Highlight any concepts to revisit\n"
+        "- Encourage further learning and effort\n\n"
+        f"{combined_content}\n"
+        "=== EVALUATION COMPLETE ===\n\n"
+        "Notes:\n"
+        "- 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 5 up to 10 additional marks for effort or "
+        "partial relevance, ensuring the score does not exceed 100."
+    )
+
+
+def prompt_text_sql(combined_content: str):
+    return (
+            "You are a SQL expert evaluating beginner SQL queries. "
+            "Focus on query correctness, efficiency, proper use of SQL syntax (e.g., SELECT, JOIN, WHERE), "
+            "and alignment with the question's requirements.\n\n"
+            "Your evaluation should:\n"
+            "- Focus on clarity, correctness, and understanding of the SQL content\n"
+            "- Be constructive and encouraging (students are beginners)\n"
+            "- Highlight both strengths and areas for improvement\n"
+            "- Identify major mistakes or misunderstandings (e.g., syntax errors, incorrect logic, missing components)\n"
+            "- Also assess whether the student’s answer demonstrates a proper understanding of the "
+            "SQL Server concepts being tested (e.g., joins, subqueries, indexing, optimization, "
+            "if required in homework's task), not just correct syntax.\n"
+            "- Be concise but insightful\n"
+            "- Look for correct use of SQL Server-specific features (e.g., Common Table Expressions, "
+            "Window Functions, transactions, if required in homework's task)\n"
+            "- If the student's answer 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 "
+            "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, "
+            "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."
+            "- Check for query optimization and adherence to the question's intent\n\n"
+            "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, misunderstanding, incomplete solutions)\n\n"
+            "KEY ADVICE:\n"
+            "- Top 2 or 3 suggestions to improve SQL skills\n"
+            "- Highlight any concepts to revisit\n"
+            "- Encourage further learning and effort\n\n"
+            f"{combined_content}\n"
+            "=== EVALUATION COMPLETE ===\n\n"
+            "Notes:\n"
+            "- 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 5 up to 10 additional marks for "
+            "effort or partial relevance, ensuring the score does not exceed 100."
+        )
+
+def prompt_text_ssis(combined_content):
+    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."
+        )
+
+def prompt_text_powerbi(combined_content: str):
+    return (
+    "You are a BI professional evaluating Power BI report solutions, including DAX formulas, "
+    "data models, and visual design based on the given task.\n\n"
+    "Your evaluation should:\n"
+    "- Focus on clarity, correctness, and understanding of Power BI content (DAX, data models, visuals)\n"
+    "- Be constructive and encouraging (students are beginners)\n"
+    "- Highlight strengths and areas for improvement\n"
+    "- Identify major mistakes (e.g., incorrect DAX, poor data modeling, unclear visuals)\n"
+    "- Be concise but insightful\n"
+    "- Evaluate proper configuration of data model relationships, correctness and logic of DAX formulas, and "
+    "clarity of visuals (e.g., appropriate chart types, layout, readability, proper filtering)\n"
+    "- Also assess whether the student’s submission demonstrates a proper understanding of "
+    "Power BI concepts being tested (e.g., data modeling, DAX calculations, visualization principles), not just technical correctness\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 "
+    "Power BI concepts (e.g., data modeling, DAX, or visualization) 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 Power BI concepts without providing the correct solution\n"
+    "- Do not penalize for advanced efficiency, data source paths, or separate measure tables\n"
+    "- Do not lower marks for redundant date tables or missing advanced design features\n\n"
+    "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., incorrect DAX, missing visuals, poor relationships)\n\n"
+    "KEY ADVICE:\n"
+    "- Top 2-3 suggestions to improve Power BI skills\n"
+    "- Highlight any concepts to revisit\n"
+    "- Encourage further learning and effort\n\n"
+
+    f"{combined_content}\n"
+    "=== EVALUATION COMPLETE ===\n\n"
+    "Notes:\n"
+    "- Be honest but supportive\n"
+    "- Include specific examples from the provided answers if helpful\n"
+    "- Keep language beginner-friendly\n"
+    "- Score submissions based on alignment with the question, effort, and technical correctness. "
+    "Off-topic or incomplete submissions should generally score low (e.g., 10-30/100), "
+    "but add from 5 up to 10 marks for effort or partial relevance, ensuring the score does not exceed 100."
+)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

{quantumchecker-0.2.3 → quantumchecker-0.2.5}/QuantumChecker.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuantumChecker
-Version: 0.2.3
+Version: 0.2.5
 Summary: A package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS.
 Author: Qobiljon
 Author-email: qobiljonkhayrullayev@gmail.com

{quantumchecker-0.2.3 → quantumchecker-0.2.5}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="QuantumChecker",
-    version="0.2.3",
+    version="0.2.5",
     author="Qobiljon",
     author_email="qobiljonkhayrullayev@gmail.com",
     description="A package to evaluate homework submissions in Python, SQL, PowerBI, and SSIS.",

quantumchecker-0.2.3/QuantumCheck/prompts.py

@@ -1,140 +0,0 @@
-
-def prompt_text_python(combined_content):
-    return (
-        "You are an expert Python instructor evaluating beginner Python code. "
-        "Focus on syntax, logic, code readability, and adherence to Python best practices (e.g., PEP 8).\n\n"
-        "IMPORTANT: First, check if the student's answer is relevant to Python. "
-        "If it is clearly from a different subject (e.g., SQL, Power BI), assign a low score (10–25/100) "
-        "and explain the mismatch supportively.\n\n"
-        "Your evaluation should:\n"
-        "- Focus on clarity, correctness, and understanding of the Python content\n"
-        "- Be constructive and encouraging (students are beginners)\n"
-        "- Highlight both strengths and areas for improvement\n"
-        "- Identify major mistakes or misunderstandings (e.g., syntax errors, incorrect logic, missing components)\n"
-        "- Be concise but insightful\n\n"
-        "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, misunderstanding, incomplete solutions)\n\n"
-        "KEY ADVICE:\n"
-        "- Top 2-3 suggestions to improve Python skills\n"
-        "- Highlight any concepts to revisit\n"
-        "- Encourage further learning and effort\n\n"
-        f"{combined_content}\n"
-        "=== EVALUATION COMPLETE ===\n\n"
-        "Notes:\n"
-        "- 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 unless the answer is entirely unrelated."
-    )
-
-def prompt_text_sql(combined_content):
-    return (
-        "You are a SQL expert evaluating beginner SQL queries. "
-        "Focus on query correctness, efficiency, proper use of SQL syntax, and alignment with the question's requirements.\n\n"
-        "IMPORTANT: First, check if the student's answer is relevant to SQL. "
-        "If the answer is clearly about a different subject (e.g., Python or Power BI), assign a low score (10–25/100) "
-        "and explain the mismatch in a supportive way.\n\n"
-        "Your evaluation should:\n"
-        "- Focus on clarity, correctness, and understanding of the SQL content\n"
-        "- Be constructive and encouraging (students are beginners)\n"
-        "- Highlight both strengths and areas for improvement\n"
-        "- Identify major mistakes or misunderstandings\n"
-        "- Be concise but insightful\n"
-        "- Check for query optimization and adherence to the question's intent\n\n"
-        "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, misunderstanding, incomplete solutions)\n\n"
-        "KEY ADVICE:\n"
-        "- Top 2-3 suggestions to improve SQL skills\n"
-        "- Highlight any concepts to revisit\n"
-        "- Encourage further learning and effort\n\n"
-        "FEEDBACK SUMMARY (in Uzbek):\n"
-        "- Nima yaxshi bajarilgan\n"
-        "- Nimalar ustida ishlash kerak\n"
-        "- Jiddiy xatoliklar yoki noto‘g‘ri tushunchalar\n\n"
-        f"{combined_content}\n"
-        "=== EVALUATION COMPLETE ===\n\n"
-        "Notes:\n"
-        "- 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 unless the subject is clearly unrelated."
-    )
-
-def prompt_text_ssis(combined_content):
-    return (
-        "You are a data engineer reviewing an SSIS package (.dtsx) summary. "
-        "Evaluate the correctness of tasks, data flow, control flow, and configurations.\n\n"
-        "IMPORTANT: First, check if the answer is related to SSIS. "
-        "If the answer is clearly unrelated (e.g., contains Python or SQL code), assign a low score (10–25/100) "
-        "and explain the mismatch supportively.\n\n"
-        "Your evaluation should:\n"
-        "- Assess how well the package addresses the question\n"
-        "- Focus on clarity, accuracy, and understanding of key SSIS components\n"
-        "- Be supportive and constructive\n"
-        "- Highlight what was done well and what could be improved\n"
-        "- Point out only major issues if necessary\n"
-        "- Keep feedback clear and insightful\n"
-        "- Do not penalize for lack of advanced scheduling (e.g., SQL Agent use)\n\n"
-        "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 if helpful\n"
-        "- Keep language beginner-friendly\n"
-        "- Give credit for effort, even if technically incorrect. Use low scores only if clearly unrelated."
-    )
-
-def prompt_text_powerbi(combined_content):
-    return (
-        "You are a BI professional evaluating Power BI report solutions, including DAX formulas, "
-        "data models, and visual design.\n\n"
-        "IMPORTANT: First, check if the student's answer is related to Power BI. "
-        "If it is clearly from a different domain (e.g., Python or SQL code), assign a low score (10–25/100) "
-        "and clearly explain the mismatch.\n\n"
-        "Your evaluation should:\n"
-        "- Focus on clarity, correctness, and understanding of Power BI content\n"
-        "- Be constructive and encouraging (students are beginners)\n"
-        "- Highlight strengths and areas for improvement\n"
-        "- Identify major mistakes (e.g., incorrect DAX, poor data modeling)\n"
-        "- Be concise but insightful\n"
-        "- Evaluate DAX, visuals, and data model structure\n"
-        "- Avoid penalizing for advanced design features or best practices\n\n"
-        "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., incorrect DAX, missing visuals, poor relationships)\n\n"
-        "KEY ADVICE:\n"
-        "- Top 2-3 suggestions to improve Power BI skills\n"
-        "- Highlight any concepts to revisit\n"
-        "- Encourage further learning and effort\n\n"
-        f"{combined_content}\n"
-        "=== EVALUATION COMPLETE ===\n\n"
-        "Notes:\n"
-        "- Be honest but supportive\n"
-        "- If the subject is mismatched, clearly state that in feedback and give a low score (10–25/100)\n"
-        "- Keep language beginner-friendly"
-    )