QuantumChecker 0.3.4__tar.gz → 0.3.7__tar.gz

{quantumchecker-0.3.4 → quantumchecker-0.3.7}/PKG-INFO

@@ -1,52 +1,52 @@
-Metadata-Version: 2.4
-Name: QuantumChecker
-Version: 0.3.4
-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"
-    question_type = "python"
-
-    result = await evaluator.evaluate_from_content(
-        question_content=question_content,
-        answer_path=answer_path,
-        api_key="your_api_key",
-        question_type=question_type
-    )
-    print(result)
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
+Metadata-Version: 2.4
+Name: QuantumChecker
+Version: 0.3.7
+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"
+    question_type = "python"
+
+    result = await evaluator.evaluate_from_content(
+        question_content=question_content,
+        answer_path=answer_path,
+        api_key="your_api_key",
+        question_type=question_type
+    )
+    print(result)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

{quantumchecker-0.3.4 → quantumchecker-0.3.7}/QuantumCheck/powerbi_evaluator.py

@@ -1,3 +1,5 @@
+import base64
+import io
 import json
 import logging
 import os
@@ -6,33 +8,33 @@ import shutil
 import zipfile
 from pathlib import Path
 from typing import Dict, List
-from pdf2image import convert_from_path
-from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
 import requests
 from dotenv import load_dotenv
+from pdf2image import convert_from_path
 from PIL import Image
-import io
-import base64
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
 
 
 def prompt_text_powerbi(combined_content: str) -> str:
     return f"""
             You are an expert Power BI instructor evaluating beginner-level DAX question-answer pairs.
-            
+
             Each answer contains a data model (in JSON format) extracted from a submitted .pbit file. Evaluate the technical correctness, relevance, and clarity of the DAX elements provided.
-            
+
             Use the following criteria to give a fair and supportive evaluation:
             - Measures (40 points): Are calculated measures meaningful, syntactically valid, and aligned with the question?
             - Relationships (20 points): Are key relationships between tables defined logically?
             - Tables & Columns (20 points): Are relevant tables/columns present? Are naming conventions clear?
             - Expressions (10 points): Are query partitions or expressions present and understandable?
             - Overall structure (10 points): Does the model appear coherent and purposeful?
-            
+
             **Scoring Tolerance**:
             - Be kind to beginners. Do not give extremely low scores unless the model is completely missing or incorrect.
             - If measures exist and make some sense, award partial credit (e.g., 20–30 out of 40).
             - A score below 30/100 should only be given if there’s little to no relevant content.
-            
+
             Structure your response exactly like this:
             OVERALL SCORE: [SCORE]/100  
             [Brief feedback here — 3–5 sentences focused on strengths + areas to improve.]
@@ -51,8 +53,11 @@ logging.basicConfig(
 )
 
 
+# ==============================
+# Gemini Flash Model
+# ==============================
 class GeminiFlashModel:
-    def __init__(self, api_key: str, model_name: str = "gemini-1.5-flash"):
+    def __init__(self, api_key: str, model_name: str = "gemini-2.5-flash"):
         api_key = os.getenv("GEMINI_API_KEY") or api_key
         if not api_key:
             raise ValueError("API key not found in .env file or environment variables.")
@@ -164,6 +169,7 @@ class GeminiFlashModel:
             return result
 
 
+
 class PowerBIProcessor:
     def extract_datamodel(self, pbit_file_path: str) -> Dict:
         if not os.path.exists(pbit_file_path):
@@ -174,7 +180,7 @@ class PowerBIProcessor:
         export_path = os.path.join(folder_path, "export")
         self._cleanup(zip_file, export_path)
         try:
-            os.rename(pbit_file_path, zip_file)
+            shutil.copy(pbit_file_path, zip_file)
             if not zipfile.is_zipfile(zip_file):
                 raise ProcessingError(f"File is not a valid ZIP: {zip_file}")
             with zipfile.ZipFile(zip_file, "r") as zip_ref:
@@ -215,7 +221,6 @@ class PowerBIProcessor:
                 image_path = os.path.join(output_dir, f"page_{i + 1}.png")
                 page.save(image_path, "PNG")
                 image_paths.append(image_path)
-            os.remove(pdf_path)
             return image_paths
         except Exception as e:
             raise ProcessingError(f"Failed to process PDF: {e}")
@@ -249,7 +254,9 @@ 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
@@ -267,7 +274,8 @@ class PowerBIProcessor:
                 }
                 for col in table.get("columns", [])
             ]
-            expressions = [part["source"]["expression"] for part in table.get("partitions", []) if part["source"].get("expression")]
+            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
 
@@ -294,6 +302,7 @@ class PowerBIProcessor:
                     shutil.rmtree(path, ignore_errors=True)
 
 
+
 class PowerBIEvaluator:
     def __init__(self, api_key: str):
         self.api_key = api_key
@@ -301,67 +310,81 @@ class PowerBIEvaluator:
         self.processor = PowerBIProcessor()
 
     def evaluate(self, questions: List[str], answer_path: str, temp_dir: str = "temp_extract") -> Dict[str, any]:
+        extract_path = temp_dir
+        outputimages = os.path.join(temp_dir, "outputimages")
         try:
             _, ext = os.path.splitext(answer_path)
             ext = ext.lower()
             extract_path = temp_dir
             pbit_path = None
             pdf_path = None
+
             if ext == ".zip":
                 pbit_path, pdf_path = self.processor.extract_zip(answer_path, extract_path)
             elif ext == ".pbit":
                 pbit_path = answer_path
-                pdf_path = None
+            elif ext == ".pdf":
+                pdf_path = answer_path
             else:
-                logger.error("Invalid file type for Power BI: %s", answer_path)
                 return {
                     "score": 0,
-                    "feedback": f"Invalid file type: {ext}. Expected .pbit or .zip",
+                    "feedback": f"Invalid file type: {ext}. Expected .pbit, .pdf, or .zip",
                     "issues": ["Invalid file type"],
                     "recommendations": [],
                     "dax_score": 0,
                     "visual_score": 0
                 }
-            try:
+
+            dax_result = None
+            visual_result = None
+
+            if pbit_path:
                 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)])
-                result = {
-                    "score": 0,
-                    "feedback": f"DAX Feedback:\n{dax_result['feedback']}",
-                    "issues": dax_result["issues"],
-                    "recommendations": dax_result["recommendations"],
-                    "dax_score": dax_result["score"],
-                    "visual_score": 0
-                }
-                if pdf_path:
-                    try:
-                        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"]
-                        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))
-                        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")
-                else:
-                    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")
-                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:
-                self.processor._cleanup(extract_path, os.path.join(temp_dir, "outputimages"))
+
+            if pdf_path:
+                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": 0,
+                "feedback": "",
+                "issues": [],
+                "recommendations": [],
+                "dax_score": 0,
+                "visual_score": 0
+            }
+
+            if dax_result:
+                result["dax_score"] = dax_result["score"]
+                result["feedback"] += f"DAX Feedback:\n{dax_result['feedback']}"
+                result["issues"].extend(dax_result["issues"])
+                result["recommendations"].extend(dax_result["recommendations"])
+
+            if visual_result:
+                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", []))
+
+            if dax_result and visual_result:
+                result["score"] = int(0.7 * dax_result["score"] + 0.3 * visual_result["score"])
+            elif dax_result:
+                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")
+            elif visual_result:
+                result["score"] = visual_result["score"]
+                result["feedback"] = "No DAX provided for evaluation.\n\n" + result["feedback"]
+                result["issues"].append("No PBIT provided for DAX evaluation")
+                result["recommendations"].append("Include a PBIT file with data model for complete evaluation")
+
+            return result
+
         except Exception as e:
-            logger.exception("Failed to evaluate Power BI file %s: %s", answer_path, str(e))
             self.processor._cleanup(extract_path, os.path.join(temp_dir, "outputimages"))
             return {
                 "score": 0,
@@ -371,6 +394,9 @@ class PowerBIEvaluator:
                 "dax_score": 0,
                 "visual_score": 0
             }
+        finally:
+            self.processor._cleanup(extract_path, outputimages)
+
 
 
 class ProcessingError(Exception):

{quantumchecker-0.3.4 → quantumchecker-0.3.7}/QuantumCheck/prompts.py

@@ -84,42 +84,35 @@ def prompt_text_sql(combined_content: str):
 
 def prompt_text_ssis(combined_content: str) -> str:
     return (
-
         "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"
+        "- Always reward genuine effort.\n\n"
+        "Feedback Format (keep total under 120 words):\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"
+        "- What was done well (1–2 sentences)\n"
+        "- What needs improvement (1–2 sentences)\n"
+        "- Major issues (if any, 1 sentence)\n\n"
         "KEY ADVICE:\n"
-        "- 1–2 improvement tips\n"
+        "- 1–2 improvement tips (1 line each)\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"
+        "- Be concise, clear, and beginner-friendly.\n"
     )
 
+
 def prompt_text_powerbi(combined_content: str):
     return (
     "You are a BI professional evaluating a beginner student's Power BI submission, including DAX, data models, and visuals.\n\n"

{quantumchecker-0.3.4 → quantumchecker-0.3.7}/QuantumCheck/python_evaluator.py

@@ -19,7 +19,7 @@ logger = logging.getLogger(__name__)
 
 
 class GeminiFlashModel:
-    def __init__(self, api_key: str, model_name: str = "gemini-1.5-flash"):
+    def __init__(self, api_key: str, model_name: str = "gemini-2.5-flash"):
         if not api_key:
             raise ValueError("API key is required.")
         self.api_key = api_key

{quantumchecker-0.3.4 → quantumchecker-0.3.7}/QuantumCheck/sql_evaluator.py

@@ -19,7 +19,7 @@ logger = logging.getLogger(__name__)
 
 
 class GeminiFlashModel:
-    def __init__(self, api_key: str, model_name: str = "gemini-1.5-flash"):
+    def __init__(self, api_key: str, model_name: str = "gemini-2.5-flash"):
         if not api_key:
             raise ValueError("API key is required.")
         self.api_key = api_key

{quantumchecker-0.3.4 → quantumchecker-0.3.7}/QuantumCheck/ssis_evaluator.py

@@ -7,7 +7,6 @@ from typing import List, Dict
 import requests
 from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
 from pprint import pprint
-import json
 import re
 
 from .prompts import prompt_text_ssis
@@ -16,7 +15,7 @@ logger = logging.getLogger(__name__)
 
 
 class GeminiFlashModel:
-    def __init__(self, api_key: str, model_name: str = "gemini-1.5-flash"):
+    def __init__(self, api_key: str, model_name: str = "gemini-2.5-flash"):
         if not api_key:
             raise ValueError("API key is required.")
         self.api_key = api_key
@@ -207,11 +206,6 @@ class SSISAnswerParser:
                 logger.warning("No valid answers found in single SSIS file")
                 answers = [combined_summary]
 
-
-            with open("parsed_ssis_summary.json", "w", encoding="utf-8") as f:
-                json.dump(structured_data, f, indent=2)
-            logger.info("Saved structured SSIS summary to 'parsed_ssis_summary.json'")
-
             return {
                 "text_answers": answers,
                 "structured_data": structured_data
@@ -219,9 +213,6 @@ class SSISAnswerParser:
 
         except ET.ParseError as e:
             logger.error("Invalid SSIS package file: %s", str(e))
-            with open("debug_dtsx_content.txt", "w", encoding="utf-8") as f:
-                f.write(content)
-            logger.info("Saved raw .dtsx content to 'debug_dtsx_content.txt' for debugging")
             return {"text_answers": ["Invalid SSIS package file"], "structured_data": {"issues": [str(e)]}}
         except Exception as e:
             logger.error("Unexpected error parsing .dtsx file: %s", str(e))

{quantumchecker-0.3.4 → quantumchecker-0.3.7}/QuantumChecker.egg-info/PKG-INFO

@@ -1,52 +1,52 @@
-Metadata-Version: 2.4
-Name: QuantumChecker
-Version: 0.3.4
-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"
-    question_type = "python"
-
-    result = await evaluator.evaluate_from_content(
-        question_content=question_content,
-        answer_path=answer_path,
-        api_key="your_api_key",
-        question_type=question_type
-    )
-    print(result)
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
+Metadata-Version: 2.4
+Name: QuantumChecker
+Version: 0.3.7
+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"
+    question_type = "python"
+
+    result = await evaluator.evaluate_from_content(
+        question_content=question_content,
+        answer_path=answer_path,
+        api_key="your_api_key",
+        question_type=question_type
+    )
+    print(result)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

{quantumchecker-0.3.4 → quantumchecker-0.3.7}/QuantumChecker.egg-info/SOURCES.txt

@@ -12,4 +12,5 @@ QuantumChecker.egg-info/SOURCES.txt
 QuantumChecker.egg-info/dependency_links.txt
 QuantumChecker.egg-info/requires.txt
 QuantumChecker.egg-info/top_level.txt
-tests/test.py
+tests/test.py
+tests/test2.py

{quantumchecker-0.3.4 → quantumchecker-0.3.7}/setup.cfg

@@ -1,4 +1,4 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[egg_info]
+tag_build = 
+tag_date = 0
+

{quantumchecker-0.3.4 → quantumchecker-0.3.7}/setup.py

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

quantumchecker-0.3.7/tests/test.py

@@ -0,0 +1,38 @@
+import asyncio
+from pprint import pprint
+from QuantumCheck import HomeworkEvaluator
+
+API_KEY = "AIzaSyDw76DEINpfBVgwIEZLShhy97tvWg7BmzY"
+
+question_sets = {
+    "python": "Write a Python function to calculate factorial.\nWrite a Python script to reverse a string.",
+    "powerbi": "Create a Power BI report\nExplain DAX measures for sales analysis.",
+    "sql": "Write a SQL query to join two tables.\nWrite a SQL query for aggregate functions.",
+    "ssis": "Design an SSIS package for data import.\nExplain SSIS control flow tasks."
+}
+
+answer_paths = {
+    "python": ["../tests/answers/second_highest_salary.py"],
+    "powerbi": ["../tests/answers/random_diagrams.pdf"],
+    "sql": ["../tests/answers/second_highest_salary.sql"],
+    "ssis": ["../tests/answers/Package.dtsx"]
+}
+
+async def main():
+    evaluator = HomeworkEvaluator()
+
+    for qtype, question in question_sets.items():
+        for ans in answer_paths[qtype]:
+            evaluation = await evaluator.evaluate_from_content(
+                question_content=question,
+                answer_path=ans,
+                api_key=API_KEY,
+                question_type=qtype
+            )
+
+            print(f"{qtype} | {ans}")
+            print(f"✅ Evaluation result: {pprint(evaluation)}")
+            print("-" * 40)
+
+if __name__ == "__main__":
+    asyncio.run(main())

quantumchecker-0.3.7/tests/test2.py

@@ -0,0 +1,25 @@
+import asyncio
+from pprint import pprint
+from QuantumCheck import HomeworkEvaluator
+
+API_KEY = "AIzaSyDw76DEINpfBVgwIEZLShhy97tvWg7BmzY"
+
+question = "Create ssis file"
+answer_path = "../tests/answers/Package.dtsx"
+
+async def main():
+    evaluator = HomeworkEvaluator()
+    evaluation = await evaluator.evaluate_from_content(
+        question_content=question,
+        answer_path=answer_path,
+        api_key=API_KEY,
+        question_type="ssis"
+    )
+
+    print(f"PowerBI | {answer_path}")
+    print("✅ Evaluation result:")
+    pprint(evaluation)
+    print("-" * 40)
+
+if __name__ == "__main__":
+    asyncio.run(main())

quantumchecker-0.3.4/tests/test.py

@@ -1,82 +0,0 @@
-import asyncio
-from QuantumCheck import HomeworkEvaluator
-
-question_sets = {
-    "python_beginner": "Write a Python function to calculate factorial.\nWrite a Python script to reverse a string.",
-    "power_bi": "Create a Power BI report with a bar chart.\nExplain DAX measures for sales analysis.",
-    "sql": "Write a SQL query to join two tables.\nWrite a SQL query for aggregate functions.",
-    "ssis": "Design an SSIS package for data import.\nExplain SSIS control flow tasks."
-}
-
-answer_paths = {
-    "python": ["../tests/answer/python1.zip"],
-    "powerbi": ["../tests/answer/real.zip"],
-    "sql": ["../tests/answer/sql3.zip"],
-    "ssis": ["../tests/answer/answer.dtsx"]
-}
-
-question_type_mapping = {
-    "python_beginner": "python",
-    "power_bi": "powerbi",
-    "sql": "sql",
-    "ssis": "ssis"
-}
-
-
-def format_score(score):
-    if score >= 90:
-        return f"🟢 Excellent ({score}⭐)"
-    elif score >= 75:
-        return f"🟡 Good ({score})"
-    elif score >= 50:
-        return f"🟠 Pass ({score})"
-    else:
-        return f"🔴 Fail ({score})"
-API_KEY = "<KEY>"
-async def run_evaluation(evaluator, q_key, q_content, question_type, answer_path, index):
-    try:
-        evaluation = await evaluator.evaluate_from_content(
-            question_content=q_content,
-            answer_path=answer_path,
-            api_key=API_KEY,
-            question_type=question_type
-        )
-        score = evaluation.get("score", 0)
-        return (q_key, index, "success", score)
-    except Exception as e:
-        return (q_key, index, "error", str(e))
-
-async def main():
-    evaluator = HomeworkEvaluator()
-    tasks = []
-
-    for q_key, q_content in question_sets.items():
-        question_type = question_type_mapping[q_key]
-        paths = answer_paths.get(question_type, [])
-        if not paths:
-            print(f"⚠️ No answer paths found for question type '{question_type}'")
-            continue
-        for i in range(10):  # run each set 10 times
-            for path in paths:
-                task = run_evaluation(evaluator, q_key, q_content, question_type, path, i + 1)
-                tasks.append(task)
-
-    results = await asyncio.gather(*tasks)
-
-    # Group results by question key
-    grouped = {}
-    for q_key, index, status, output in results:
-        if q_key not in grouped:
-            grouped[q_key] = []
-        grouped[q_key].append((index, status, output))
-
-    # Sort and print all at once, grouped by question
-    for q_key in grouped:
-        print(f"\n📘 {q_key.upper()} Results")
-        for index, status, output in sorted(grouped[q_key], key=lambda x: x[0]):
-            if status == "success":
-                print(f"  ⏱️ Run {index:02}: {format_score(output)}")
-            else:
-                print(f"  ⏱️ Run {index:02}: ❌ Error - {output}")
-
-asyncio.run(main())