QuantumChecker 0.3.3__tar.gz → 0.3.6__tar.gz

{quantumchecker-0.3.3 → quantumchecker-0.3.6}/PKG-INFO

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

{quantumchecker-0.3.3 → quantumchecker-0.3.6}/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.]
@@ -43,13 +45,17 @@ def prompt_text_powerbi(combined_content: str) -> str:
 
 load_dotenv()
 logger = logging.getLogger(__name__)
+
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.FileHandler("../powerbi_evaluator.log"), logging.StreamHandler()]
+    handlers=[logging.StreamHandler()]
 )
 
 
+# ==============================
+# Gemini Flash Model
+# ==============================
 class GeminiFlashModel:
     def __init__(self, api_key: str, model_name: str = "gemini-1.5-flash"):
         api_key = os.getenv("GEMINI_API_KEY") or api_key
@@ -163,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):
@@ -173,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:
@@ -214,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}")
@@ -248,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
@@ -266,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
 
@@ -293,6 +302,7 @@ class PowerBIProcessor:
                     shutil.rmtree(path, ignore_errors=True)
 
 
+
 class PowerBIEvaluator:
     def __init__(self, api_key: str):
         self.api_key = api_key
@@ -300,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,
@@ -370,6 +394,9 @@ class PowerBIEvaluator:
                 "dax_score": 0,
                 "visual_score": 0
             }
+        finally:
+            self.processor._cleanup(extract_path, outputimages)
+
 
 
 class ProcessingError(Exception):

{quantumchecker-0.3.3 → quantumchecker-0.3.6}/QuantumCheck/ssis_evaluator.py

@@ -7,10 +7,9 @@ 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  # Assumes this is defined in .prompts
+from .prompts import prompt_text_ssis
 
 logger = logging.getLogger(__name__)
 
@@ -90,7 +89,7 @@ class SSISAnswerParser:
                 "issues": []
             }
 
-            # Parse package info
+
             package_info = {
                 "Package Name": root.attrib.get("{www.microsoft.com/SqlServer/Dts}ObjectName", "Unknown"),
                 "Creation Date": root.attrib.get("{www.microsoft.com/SqlServer/Dts}CreationDate", "Unknown"),
@@ -101,7 +100,7 @@ class SSISAnswerParser:
             structured_data["package_info"] = package_info
             summary.append(f"Package: {package_info['Package Name']} (Created: {package_info['Creation Date']})")
 
-            # Parse package description from comments
+
             package_description = "No description found"
             comment_pattern = re.compile(r'<!--\s*Package Description:\s*(.*?)\s*-->', re.DOTALL)
             match = comment_pattern.search(content)
@@ -109,7 +108,7 @@ class SSISAnswerParser:
                 package_description = match.group(1).strip()
                 summary.append(f"Description: {package_description}")
 
-            # Parse connection managers
+
             for conn in root.findall(".//DTS:ConnectionManager", namespace):
                 try:
                     conn_name = conn.attrib.get("{www.microsoft.com/SqlServer/Dts}ObjectName", "Unnamed Connection")
@@ -133,14 +132,14 @@ class SSISAnswerParser:
                     summary.append(
                         f"Connection: {conn_name} ({conn_type}, ConnectionString: {conn_details['ConnectionString']})")
                     structured_data["connections"].append(conn_details)
-                    # Validate connection
+
                     if conn_type == "OLEDB" and "Initial Catalog" not in conn_details["ConnectionString"]:
                         structured_data["issues"].append(f"OLEDB Connection {conn_name} missing database specification")
                 except AttributeError as e:
                     structured_data["issues"].append(f"Error parsing connection {conn_name}: {str(e)}")
                     logger.error("Error parsing connection %s: %s", conn_name, str(e))
 
-            # Parse variables
+
             for var in root.findall(".//DTS:Variable", namespace):
                 try:
                     var_name = var.attrib.get("{www.microsoft.com/SqlServer/Dts}ObjectName", "Unnamed Variable")
@@ -155,7 +154,7 @@ class SSISAnswerParser:
                     structured_data["issues"].append(f"Error parsing variable {var_name}: {str(e)}")
                     logger.error("Error parsing variable %s: %s", var_name, str(e))
 
-            # Parse data flow components
+
             component_ids = set()
             for component in root.findall(".//DTS:Executables//component", namespace):
                 try:
@@ -168,7 +167,7 @@ class SSISAnswerParser:
                     structured_data["issues"].append(f"Error parsing component {comp_name}: {str(e)}")
                     logger.error("Error parsing component %s: %s", comp_name, str(e))
 
-            # Parse data flow paths
+
             for path in root.findall(".//DTS:Executables//path", namespace):
                 try:
                     start_id = path.attrib.get("startId", "Unknown Start")
@@ -183,14 +182,14 @@ class SSISAnswerParser:
                     structured_data["issues"].append(f"Error parsing path {path_name}: {str(e)}")
                     logger.error("Error parsing path %s: %s", path_name, str(e))
 
-            # Additional validations
+
             if not structured_data["connections"]:
                 structured_data["issues"].append("No connections configured in the package")
             if not structured_data["data_flow_paths"]:
                 structured_data["issues"].append("No data flow paths configured in the package")
 
             combined_summary = "\n".join(summary)[:2000] or "No components found in SSIS package"
-            # Split summary into logical sections for multiple questions
+
             answers = []
             sections = ["Package", "Description", "Connection", "Variable", "Component", "Data Flow Path"]
             current_section = []
@@ -207,11 +206,6 @@ class SSISAnswerParser:
                 logger.warning("No valid answers found in single SSIS file")
                 answers = [combined_summary]
 
-            # Save structured data for debugging
-            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))
@@ -337,7 +328,7 @@ class SSISEvaluator:
         """
         try:
             if answer_path.lower().endswith(".zip"):
-                # Use provided temp_dir or generate a default one
+
                 temp_dir = temp_dir or f"temp_ssis_extract_{os.getpid()}"
                 parsed_data = SSISAnswerParser.parse_zip_file(answer_path, temp_dir)
             elif answer_path.lower().endswith('.dtsx'):
@@ -361,17 +352,17 @@ class SSISEvaluator:
             logger.info("Processing %d questions and %d answers", len(questions), len(answers))
             pprint(f"Processing {len(questions)} questions and {len(answers)} answers")
 
-            # Map answers to questions
+
             if not answers:
                 logger.warning("No answers parsed from SSIS file")
                 answers = ["No valid SSIS components found"] * len(questions)
             elif len(answers) < len(questions):
-                # Cycle through answers to match question count
+
                 answers = [answers[i % len(answers)] for i in range(len(questions))]
                 logger.debug("Expanded %d answers to %d for %d questions", len(parsed_data["text_answers"]),
                              len(answers), len(questions))
             elif len(answers) > len(questions):
-                # Truncate to match question count
+
                 answers = answers[:len(questions)]
                 logger.debug("Truncated %d answers to %d for %d questions", len(parsed_data["text_answers"]),
                              len(answers), len(questions))

{quantumchecker-0.3.3 → quantumchecker-0.3.6}/QuantumChecker.egg-info/PKG-INFO

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

{quantumchecker-0.3.3 → quantumchecker-0.3.6}/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.3 → quantumchecker-0.3.6}/setup.py

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

quantumchecker-0.3.6/tests/test.py

@@ -0,0 +1,45 @@
+import asyncio
+import os
+import psutil
+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 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/homework2_last.pdf"],
+    "sql": ["../tests/answer/sql3.zip"],
+    "ssis": ["../tests/answer/answer.dtsx"]
+}
+
+async def main():
+    evaluator = HomeworkEvaluator()
+    process = psutil.Process(os.getpid())
+
+    for qtype, question in question_sets.items():
+        for ans in answer_paths[qtype]:
+            mem_before = process.memory_info().rss
+            evaluation = await evaluator.evaluate_from_content(
+                question_content=question,
+                answer_path=ans,
+                api_key=API_KEY,
+                question_type=qtype
+            )
+            mem_after = process.memory_info().rss
+            delta_mb = (mem_after - mem_before) / 1024**2
+
+            print(f"{qtype} | {ans}")
+            print(f"📈 Memory used for evaluation: {delta_mb:.2f} MB")
+            print(f"✅ Evaluation result: {pprint(evaluation)}")
+            print("-" * 40)
+
+if __name__ == "__main__":
+    asyncio.run(main())

quantumchecker-0.3.6/tests/test2.py

@@ -0,0 +1,25 @@
+import asyncio
+from pprint import pprint
+from QuantumCheck import HomeworkEvaluator
+
+API_KEY = "AIzaSyDw76DEINpfBVgwIEZLShhy97tvWg7BmzY"
+
+question = "Create a Power BI report with a bar chart.\nExplain DAX measures for sales analysis."
+answer_path = "../tests/answer/test.pdf"
+
+async def main():
+    evaluator = HomeworkEvaluator()
+    evaluation = await evaluator.evaluate_from_content(
+        question_content=question,
+        answer_path=answer_path,
+        api_key=API_KEY,
+        question_type="powerbi"
+    )
+
+    print(f"PowerBI | {answer_path}")
+    print("✅ Evaluation result:")
+    pprint(evaluation)
+    print("-" * 40)
+
+if __name__ == "__main__":
+    asyncio.run(main())

quantumchecker-0.3.3/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())